@xelauvas/xela-cli 0.1.0

package/src/commands/plugin/ManagePlugins.tsx

@@ -0,0 +1,2215 @@
+import figures from 'figures';
+import type { Dirent } from 'fs';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as React from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { ConfigurableShortcutHint } from '../../components/ConfigurableShortcutHint.js';
+import { Byline } from '../../components/design-system/Byline.js';
+import { MCPRemoteServerMenu } from '../../components/mcp/MCPRemoteServerMenu.js';
+import { MCPStdioServerMenu } from '../../components/mcp/MCPStdioServerMenu.js';
+import { MCPToolDetailView } from '../../components/mcp/MCPToolDetailView.js';
+import { MCPToolListView } from '../../components/mcp/MCPToolListView.js';
+import type { ClaudeAIServerInfo, HTTPServerInfo, SSEServerInfo, StdioServerInfo } from '../../components/mcp/types.js';
+import { SearchBox } from '../../components/SearchBox.js';
+import { useSearchInput } from '../../hooks/useSearchInput.js';
+import { useTerminalSize } from '../../hooks/useTerminalSize.js';
+// eslint-disable-next-line custom-rules/prefer-use-keybindings -- useInput needed for raw search mode text input
+import { Box, Text, useInput, useTerminalFocus } from '../../ink.js';
+import { useKeybinding, useKeybindings } from '../../keybindings/useKeybinding.js';
+import { getBuiltinPluginDefinition } from '../../plugins/builtinPlugins.js';
+import { useMcpToggleEnabled } from '../../services/mcp/MCPConnectionManager.js';
+import type { MCPServerConnection, McpClaudeAIProxyServerConfig, McpHTTPServerConfig, McpSSEServerConfig, McpStdioServerConfig } from '../../services/mcp/types.js';
+import { filterToolsByServer } from '../../services/mcp/utils.js';
+import { disablePluginOp, enablePluginOp, getPluginInstallationFromV2, isInstallableScope, isPluginEnabledAtProjectScope, uninstallPluginOp, updatePluginOp } from '../../services/plugins/pluginOperations.js';
+import { useAppState } from '../../state/AppState.js';
+import type { Tool } from '../../Tool.js';
+import type { LoadedPlugin, PluginError } from '../../types/plugin.js';
+import { count } from '../../utils/array.js';
+import { openBrowser } from '../../utils/browser.js';
+import { logForDebugging } from '../../utils/debug.js';
+import { errorMessage, toError } from '../../utils/errors.js';
+import { logError } from '../../utils/log.js';
+import { clearAllCaches } from '../../utils/plugins/cacheUtils.js';
+import { loadInstalledPluginsV2 } from '../../utils/plugins/installedPluginsManager.js';
+import { getMarketplace } from '../../utils/plugins/marketplaceManager.js';
+import { isMcpbSource, loadMcpbFile, type McpbNeedsConfigResult, type UserConfigValues } from '../../utils/plugins/mcpbHandler.js';
+import { getPluginDataDirSize, pluginDataDirPath } from '../../utils/plugins/pluginDirectories.js';
+import { getFlaggedPlugins, markFlaggedPluginsSeen, removeFlaggedPlugin } from '../../utils/plugins/pluginFlagging.js';
+import { type PersistablePluginScope, parsePluginIdentifier } from '../../utils/plugins/pluginIdentifier.js';
+import { loadAllPlugins } from '../../utils/plugins/pluginLoader.js';
+import { loadPluginOptions, type PluginOptionSchema, savePluginOptions } from '../../utils/plugins/pluginOptionsStorage.js';
+import { isPluginBlockedByPolicy } from '../../utils/plugins/pluginPolicy.js';
+import { getPluginEditableScopes } from '../../utils/plugins/pluginStartupCheck.js';
+import { getSettings_DEPRECATED, getSettingsForSource, updateSettingsForSource } from '../../utils/settings/settings.js';
+import { jsonParse } from '../../utils/slowOperations.js';
+import { plural } from '../../utils/stringUtils.js';
+import { formatErrorMessage, getErrorGuidance } from './PluginErrors.js';
+import { PluginOptionsDialog } from './PluginOptionsDialog.js';
+import { PluginOptionsFlow } from './PluginOptionsFlow.js';
+import type { ViewState as ParentViewState } from './types.js';
+import { UnifiedInstalledCell } from './UnifiedInstalledCell.js';
+import type { UnifiedInstalledItem } from './unifiedTypes.js';
+import { usePagination } from './usePagination.js';
+type Props = {
+  setViewState: (state: ParentViewState) => void;
+  setResult: (result: string | null) => void;
+  onManageComplete?: () => void | Promise<void>;
+  onSearchModeChange?: (isActive: boolean) => void;
+  targetPlugin?: string;
+  targetMarketplace?: string;
+  action?: 'enable' | 'disable' | 'uninstall';
+};
+type FlaggedPluginInfo = {
+  id: string;
+  name: string;
+  marketplace: string;
+  reason: string;
+  text: string;
+  flaggedAt: string;
+};
+type FailedPluginInfo = {
+  id: string;
+  name: string;
+  marketplace: string;
+  errors: PluginError[];
+  scope: PersistablePluginScope;
+};
+type ViewState = 'plugin-list' | 'plugin-details' | 'configuring' | {
+  type: 'plugin-options';
+} | {
+  type: 'configuring-options';
+  schema: PluginOptionSchema;
+} | 'confirm-project-uninstall' | {
+  type: 'confirm-data-cleanup';
+  size: {
+    bytes: number;
+    human: string;
+  };
+} | {
+  type: 'flagged-detail';
+  plugin: FlaggedPluginInfo;
+} | {
+  type: 'failed-plugin-details';
+  plugin: FailedPluginInfo;
+} | {
+  type: 'mcp-detail';
+  client: MCPServerConnection;
+} | {
+  type: 'mcp-tools';
+  client: MCPServerConnection;
+} | {
+  type: 'mcp-tool-detail';
+  client: MCPServerConnection;
+  tool: Tool;
+};
+type MarketplaceInfo = {
+  name: string;
+  installedPlugins: LoadedPlugin[];
+  enabledCount?: number;
+  disabledCount?: number;
+};
+type PluginState = {
+  plugin: LoadedPlugin;
+  marketplace: string;
+  scope?: 'user' | 'project' | 'local' | 'managed' | 'builtin';
+  pendingEnable?: boolean; // Toggle enable/disable
+  pendingUpdate?: boolean; // Marked for update
+};
+
+/**
+ * Get list of base file names (without .md extension) from a directory
+ * @param dirPath The directory path to list files from
+ * @returns Array of base file names without .md extension
+ * @example
+ * // Given directory contains: agent-sdk-verifier-py.md, agent-sdk-verifier-ts.md, README.txt
+ * await getBaseFileNames('/path/to/agents')
+ * // Returns: ['agent-sdk-verifier-py', 'agent-sdk-verifier-ts']
+ */
+async function getBaseFileNames(dirPath: string): Promise<string[]> {
+  try {
+    const entries = await fs.readdir(dirPath, {
+      withFileTypes: true
+    });
+    return entries.filter((entry: Dirent) => entry.isFile() && entry.name.endsWith('.md')).map((entry: Dirent) => {
+      // Remove .md extension specifically
+      const baseName = path.basename(entry.name, '.md');
+      return baseName;
+    });
+  } catch (error) {
+    const errorMsg = errorMessage(error);
+    logForDebugging(`Failed to read plugin components from ${dirPath}: ${errorMsg}`, {
+      level: 'error'
+    });
+    logError(toError(error));
+    // Return empty array to allow graceful degradation - plugin details can still be shown
+    return [];
+  }
+}
+
+/**
+ * Get list of skill directory names from a skills directory
+ * Skills are directories containing a SKILL.md file
+ * @param dirPath The skills directory path to scan
+ * @returns Array of skill directory names that contain SKILL.md
+ * @example
+ * // Given directory contains: my-skill/SKILL.md, another-skill/SKILL.md, README.txt
+ * await getSkillDirNames('/path/to/skills')
+ * // Returns: ['my-skill', 'another-skill']
+ */
+async function getSkillDirNames(dirPath: string): Promise<string[]> {
+  try {
+    const entries = await fs.readdir(dirPath, {
+      withFileTypes: true
+    });
+    const skillNames: string[] = [];
+    for (const entry of entries) {
+      // Check if it's a directory or symlink (symlinks may point to skill directories)
+      if (entry.isDirectory() || entry.isSymbolicLink()) {
+        // Check if this directory contains a SKILL.md file
+        const skillFilePath = path.join(dirPath, entry.name, 'SKILL.md');
+        try {
+          const st = await fs.stat(skillFilePath);
+          if (st.isFile()) {
+            skillNames.push(entry.name);
+          }
+        } catch {
+          // No SKILL.md file in this directory, skip it
+        }
+      }
+    }
+    return skillNames;
+  } catch (error) {
+    const errorMsg = errorMessage(error);
+    logForDebugging(`Failed to read skill directories from ${dirPath}: ${errorMsg}`, {
+      level: 'error'
+    });
+    logError(toError(error));
+    // Return empty array to allow graceful degradation - plugin details can still be shown
+    return [];
+  }
+}
+
+// Component to display installed plugin components
+function PluginComponentsDisplay({
+  plugin,
+  marketplace
+}: {
+  plugin: LoadedPlugin;
+  marketplace: string;
+}): React.ReactNode {
+  const [components, setComponents] = useState<{
+    commands?: string | string[] | Record<string, unknown> | null;
+    agents?: string | string[] | Record<string, unknown> | null;
+    skills?: string | string[] | Record<string, unknown> | null;
+    hooks?: unknown;
+    mcpServers?: unknown;
+  } | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  useEffect(() => {
+    async function loadComponents() {
+      try {
+        // Built-in plugins don't have a marketplace entry — read from the
+        // registered definition directly.
+        if (marketplace === 'builtin') {
+          const builtinDef = getBuiltinPluginDefinition(plugin.name);
+          if (builtinDef) {
+            const skillNames = builtinDef.skills?.map(s => s.name) ?? [];
+            const hookEvents = builtinDef.hooks ? Object.keys(builtinDef.hooks) : [];
+            const mcpServerNames = builtinDef.mcpServers ? Object.keys(builtinDef.mcpServers) : [];
+            setComponents({
+              commands: null,
+              agents: null,
+              skills: skillNames.length > 0 ? skillNames : null,
+              hooks: hookEvents.length > 0 ? hookEvents : null,
+              mcpServers: mcpServerNames.length > 0 ? mcpServerNames : null
+            });
+          } else {
+            setError(`Built-in plugin ${plugin.name} not found`);
+          }
+          setLoading(false);
+          return;
+        }
+        const marketplaceData = await getMarketplace(marketplace);
+        // Find the plugin entry in the array
+        const pluginEntry = marketplaceData.plugins.find(p => p.name === plugin.name);
+        if (pluginEntry) {
+          // Combine commands from both sources
+          const commandPathList = [];
+          if (plugin.commandsPath) {
+            commandPathList.push(plugin.commandsPath);
+          }
+          if (plugin.commandsPaths) {
+            commandPathList.push(...plugin.commandsPaths);
+          }
+
+          // Get base file names from all command paths
+          const commandList: string[] = [];
+          for (const commandPath of commandPathList) {
+            if (typeof commandPath === 'string') {
+              // commandPath is already a full path
+              const baseNames = await getBaseFileNames(commandPath);
+              commandList.push(...baseNames);
+            }
+          }
+
+          // Combine agents from both sources
+          const agentPathList = [];
+          if (plugin.agentsPath) {
+            agentPathList.push(plugin.agentsPath);
+          }
+          if (plugin.agentsPaths) {
+            agentPathList.push(...plugin.agentsPaths);
+          }
+
+          // Get base file names from all agent paths
+          const agentList: string[] = [];
+          for (const agentPath of agentPathList) {
+            if (typeof agentPath === 'string') {
+              // agentPath is already a full path
+              const baseNames_0 = await getBaseFileNames(agentPath);
+              agentList.push(...baseNames_0);
+            }
+          }
+
+          // Combine skills from both sources
+          const skillPathList = [];
+          if (plugin.skillsPath) {
+            skillPathList.push(plugin.skillsPath);
+          }
+          if (plugin.skillsPaths) {
+            skillPathList.push(...plugin.skillsPaths);
+          }
+
+          // Get skill directory names from all skill paths
+          // Skills are directories containing SKILL.md files
+          const skillList: string[] = [];
+          for (const skillPath of skillPathList) {
+            if (typeof skillPath === 'string') {
+              // skillPath is already a full path to a skills directory
+              const skillDirNames = await getSkillDirNames(skillPath);
+              skillList.push(...skillDirNames);
+            }
+          }
+
+          // Combine hooks from both sources
+          const hooksList = [];
+          if (plugin.hooksConfig) {
+            hooksList.push(Object.keys(plugin.hooksConfig));
+          }
+          if (pluginEntry.hooks) {
+            hooksList.push(pluginEntry.hooks);
+          }
+
+          // Combine MCP servers from both sources
+          const mcpServersList = [];
+          if (plugin.mcpServers) {
+            mcpServersList.push(Object.keys(plugin.mcpServers));
+          }
+          if (pluginEntry.mcpServers) {
+            mcpServersList.push(pluginEntry.mcpServers);
+          }
+          setComponents({
+            commands: commandList.length > 0 ? commandList : null,
+            agents: agentList.length > 0 ? agentList : null,
+            skills: skillList.length > 0 ? skillList : null,
+            hooks: hooksList.length > 0 ? hooksList : null,
+            mcpServers: mcpServersList.length > 0 ? mcpServersList : null
+          });
+        } else {
+          setError(`Plugin ${plugin.name} not found in marketplace`);
+        }
+      } catch (err) {
+        setError(err instanceof Error ? err.message : 'Failed to load components');
+      } finally {
+        setLoading(false);
+      }
+    }
+    void loadComponents();
+  }, [plugin.name, plugin.commandsPath, plugin.commandsPaths, plugin.agentsPath, plugin.agentsPaths, plugin.skillsPath, plugin.skillsPaths, plugin.hooksConfig, plugin.mcpServers, marketplace]);
+  if (loading) {
+    return null; // Don't show loading state for cleaner UI
+  }
+  if (error) {
+    return <Box flexDirection="column" marginBottom={1}>
+        <Text bold>Components:</Text>
+        <Text dimColor>Error: {error}</Text>
+      </Box>;
+  }
+  if (!components) {
+    return null; // No components info available
+  }
+  const hasComponents = components.commands || components.agents || components.skills || components.hooks || components.mcpServers;
+  if (!hasComponents) {
+    return null; // No components defined
+  }
+  return <Box flexDirection="column" marginBottom={1}>
+      <Text bold>Installed components:</Text>
+      {components.commands ? <Text dimColor>
+          • Commands:{' '}
+          {typeof components.commands === 'string' ? components.commands : Array.isArray(components.commands) ? components.commands.join(', ') : Object.keys(components.commands).join(', ')}
+        </Text> : null}
+      {components.agents ? <Text dimColor>
+          • Agents:{' '}
+          {typeof components.agents === 'string' ? components.agents : Array.isArray(components.agents) ? components.agents.join(', ') : Object.keys(components.agents).join(', ')}
+        </Text> : null}
+      {components.skills ? <Text dimColor>
+          • Skills:{' '}
+          {typeof components.skills === 'string' ? components.skills : Array.isArray(components.skills) ? components.skills.join(', ') : Object.keys(components.skills).join(', ')}
+        </Text> : null}
+      {components.hooks ? <Text dimColor>
+          • Hooks:{' '}
+          {typeof components.hooks === 'string' ? components.hooks : Array.isArray(components.hooks) ? components.hooks.map(String).join(', ') : typeof components.hooks === 'object' && components.hooks !== null ? Object.keys(components.hooks).join(', ') : String(components.hooks)}
+        </Text> : null}
+      {components.mcpServers ? <Text dimColor>
+          • MCP Servers:{' '}
+          {typeof components.mcpServers === 'string' ? components.mcpServers : Array.isArray(components.mcpServers) ? components.mcpServers.map(String).join(', ') : typeof components.mcpServers === 'object' && components.mcpServers !== null ? Object.keys(components.mcpServers).join(', ') : String(components.mcpServers)}
+        </Text> : null}
+    </Box>;
+}
+
+/**
+ * Check if a plugin is from a local source and cannot be remotely updated
+ * @returns Error message if local, null if remote/updatable
+ */
+async function checkIfLocalPlugin(pluginName: string, marketplaceName: string): Promise<string | null> {
+  const marketplace = await getMarketplace(marketplaceName);
+  const entry = marketplace?.plugins.find(p => p.name === pluginName);
+  if (entry && typeof entry.source === 'string') {
+    return `Local plugins cannot be updated remotely. To update, modify the source at: ${entry.source}`;
+  }
+  return null;
+}
+
+/**
+ * Filter out plugins that are force-disabled by org policy (policySettings).
+ * These are blocked by the organization and cannot be re-enabled by the user.
+ * Checks policySettings directly rather than installation scope, since managed
+ * settings don't create installation records with scope 'managed'.
+ */
+export function filterManagedDisabledPlugins(plugins: LoadedPlugin[]): LoadedPlugin[] {
+  return plugins.filter(plugin => {
+    const marketplace = plugin.source.split('@')[1] || 'local';
+    return !isPluginBlockedByPolicy(`${plugin.name}@${marketplace}`);
+  });
+}
+export function ManagePlugins({
+  setViewState: setParentViewState,
+  setResult,
+  onManageComplete,
+  onSearchModeChange,
+  targetPlugin,
+  targetMarketplace,
+  action
+}: Props): React.ReactNode {
+  // App state for MCP access
+  const mcpClients = useAppState(s => s.mcp.clients);
+  const mcpTools = useAppState(s_0 => s_0.mcp.tools);
+  const pluginErrors = useAppState(s_1 => s_1.plugins.errors);
+  const flaggedPlugins = getFlaggedPlugins();
+
+  // Search state
+  const [isSearchMode, setIsSearchModeRaw] = useState(false);
+  const setIsSearchMode = useCallback((active: boolean) => {
+    setIsSearchModeRaw(active);
+    onSearchModeChange?.(active);
+  }, [onSearchModeChange]);
+  const isTerminalFocused = useTerminalFocus();
+  const {
+    columns: terminalWidth
+  } = useTerminalSize();
+
+  // View state
+  const [viewState, setViewState] = useState<ViewState>('plugin-list');
+  const {
+    query: searchQuery,
+    setQuery: setSearchQuery,
+    cursorOffset: searchCursorOffset
+  } = useSearchInput({
+    isActive: viewState === 'plugin-list' && isSearchMode,
+    onExit: () => {
+      setIsSearchMode(false);
+    }
+  });
+  const [selectedPlugin, setSelectedPlugin] = useState<PluginState | null>(null);
+
+  // Data state
+  const [marketplaces, setMarketplaces] = useState<MarketplaceInfo[]>([]);
+  const [pluginStates, setPluginStates] = useState<PluginState[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [pendingToggles, setPendingToggles] = useState<Map<string, 'will-enable' | 'will-disable'>>(new Map());
+
+  // Guard to prevent auto-navigation from re-triggering after the user
+  // navigates away (targetPlugin is never cleared by the parent).
+  const hasAutoNavigated = useRef(false);
+  // Auto-action (enable/disable/uninstall) to fire after auto-navigation lands.
+  // Ref, not state: it's consumed by a one-shot effect that already re-runs on
+  // viewState/selectedPlugin, so a render-triggering state var would be redundant.
+  const pendingAutoActionRef = useRef<'enable' | 'disable' | 'uninstall' | undefined>(undefined);
+
+  // MCP toggle hook
+  const toggleMcpServer = useMcpToggleEnabled();
+
+  // Handle escape to go back - viewState-dependent navigation
+  const handleBack = React.useCallback(() => {
+    if (viewState === 'plugin-details') {
+      setViewState('plugin-list');
+      setSelectedPlugin(null);
+      setProcessError(null);
+    } else if (typeof viewState === 'object' && viewState.type === 'failed-plugin-details') {
+      setViewState('plugin-list');
+      setProcessError(null);
+    } else if (viewState === 'configuring') {
+      setViewState('plugin-details');
+      setConfigNeeded(null);
+    } else if (typeof viewState === 'object' && (viewState.type === 'plugin-options' || viewState.type === 'configuring-options')) {
+      // Cancel mid-sequence — plugin is already enabled, just bail to list.
+      // User can configure later via the Configure options menu if they want.
+      setViewState('plugin-list');
+      setSelectedPlugin(null);
+      setResult('Plugin enabled. Configuration skipped — run /reload-plugins to apply.');
+      if (onManageComplete) {
+        void onManageComplete();
+      }
+    } else if (typeof viewState === 'object' && viewState.type === 'flagged-detail') {
+      setViewState('plugin-list');
+      setProcessError(null);
+    } else if (typeof viewState === 'object' && viewState.type === 'mcp-detail') {
+      setViewState('plugin-list');
+      setProcessError(null);
+    } else if (typeof viewState === 'object' && viewState.type === 'mcp-tools') {
+      setViewState({
+        type: 'mcp-detail',
+        client: viewState.client
+      });
+    } else if (typeof viewState === 'object' && viewState.type === 'mcp-tool-detail') {
+      setViewState({
+        type: 'mcp-tools',
+        client: viewState.client
+      });
+    } else {
+      if (pendingToggles.size > 0) {
+        setResult('Run /reload-plugins to apply plugin changes.');
+        return;
+      }
+      setParentViewState({
+        type: 'menu'
+      });
+    }
+  }, [viewState, setParentViewState, pendingToggles, setResult]);
+
+  // Escape when not in search mode - go back.
+  // Excludes confirm-project-uninstall (has its own confirm:no handler in
+  // Confirmation context — letting this fire would create competing handlers)
+  // and confirm-data-cleanup (uses raw useInput where n and escape are
+  // DIFFERENT actions: keep-data vs cancel).
+  useKeybinding('confirm:no', handleBack, {
+    context: 'Confirmation',
+    isActive: (viewState !== 'plugin-list' || !isSearchMode) && viewState !== 'confirm-project-uninstall' && !(typeof viewState === 'object' && viewState.type === 'confirm-data-cleanup')
+  });
+
+  // Helper to get MCP status
+  const getMcpStatus = (client: MCPServerConnection): 'connected' | 'disabled' | 'pending' | 'needs-auth' | 'failed' => {
+    if (client.type === 'connected') return 'connected';
+    if (client.type === 'disabled') return 'disabled';
+    if (client.type === 'pending') return 'pending';
+    if (client.type === 'needs-auth') return 'needs-auth';
+    return 'failed';
+  };
+
+  // Derive unified items from plugins and MCP servers
+  const unifiedItems = useMemo(() => {
+    const mergedSettings = getSettings_DEPRECATED();
+
+    // Build map of plugin name -> child MCPs
+    // Plugin MCPs have names like "plugin:pluginName:serverName"
+    const pluginMcpMap = new Map<string, Array<{
+      displayName: string;
+      client: MCPServerConnection;
+    }>>();
+    for (const client_0 of mcpClients) {
+      if (client_0.name.startsWith('plugin:')) {
+        const parts = client_0.name.split(':');
+        if (parts.length >= 3) {
+          const pluginName = parts[1]!;
+          const serverName = parts.slice(2).join(':');
+          const existing = pluginMcpMap.get(pluginName) || [];
+          existing.push({
+            displayName: serverName,
+            client: client_0
+          });
+          pluginMcpMap.set(pluginName, existing);
+        }
+      }
+    }
+
+    // Build plugin items (unsorted for now)
+    type PluginWithChildren = {
+      item: UnifiedInstalledItem & {
+        type: 'plugin';
+      };
+      originalScope: 'user' | 'project' | 'local' | 'managed' | 'builtin';
+      childMcps: Array<{
+        displayName: string;
+        client: MCPServerConnection;
+      }>;
+    };
+    const pluginsWithChildren: PluginWithChildren[] = [];
+    for (const state of pluginStates) {
+      const pluginId = `${state.plugin.name}@${state.marketplace}`;
+      const isEnabled = mergedSettings?.enabledPlugins?.[pluginId] !== false;
+      const errors = pluginErrors.filter(e => 'plugin' in e && e.plugin === state.plugin.name || e.source === pluginId || e.source.startsWith(`${state.plugin.name}@`));
+
+      // Built-in plugins use 'builtin' scope; others look up from V2 data.
+      const originalScope = state.plugin.isBuiltin ? 'builtin' : state.scope || 'user';
+      pluginsWithChildren.push({
+        item: {
+          type: 'plugin',
+          id: pluginId,
+          name: state.plugin.name,
+          description: state.plugin.manifest.description,
+          marketplace: state.marketplace,
+          scope: originalScope,
+          isEnabled,
+          errorCount: errors.length,
+          errors,
+          plugin: state.plugin,
+          pendingEnable: state.pendingEnable,
+          pendingUpdate: state.pendingUpdate,
+          pendingToggle: pendingToggles.get(pluginId)
+        },
+        originalScope,
+        childMcps: pluginMcpMap.get(state.plugin.name) || []
+      });
+    }
+
+    // Find orphan errors (errors for plugins that failed to load entirely)
+    const matchedPluginIds = new Set(pluginsWithChildren.map(({
+      item
+    }) => item.id));
+    const matchedPluginNames = new Set(pluginsWithChildren.map(({
+      item: item_0
+    }) => item_0.name));
+    const orphanErrorsBySource = new Map<string, typeof pluginErrors>();
+    for (const error of pluginErrors) {
+      if (matchedPluginIds.has(error.source) || 'plugin' in error && typeof error.plugin === 'string' && matchedPluginNames.has(error.plugin)) {
+        continue;
+      }
+      const existing_0 = orphanErrorsBySource.get(error.source) || [];
+      existing_0.push(error);
+      orphanErrorsBySource.set(error.source, existing_0);
+    }
+    const pluginScopes = getPluginEditableScopes();
+    const failedPluginItems: UnifiedInstalledItem[] = [];
+    for (const [pluginId_0, errors_0] of orphanErrorsBySource) {
+      // Skip plugins that are already shown in the flagged section
+      if (pluginId_0 in flaggedPlugins) continue;
+      const parsed = parsePluginIdentifier(pluginId_0);
+      const pluginName_0 = parsed.name || pluginId_0;
+      const marketplace = parsed.marketplace || 'unknown';
+      const rawScope = pluginScopes.get(pluginId_0);
+      // 'flag' is session-only (from --plugin-dir / flagSettings) and undefined
+      // means the plugin isn't in any settings source. Default both to 'user'
+      // since UnifiedInstalledItem doesn't have a 'flag' scope variant.
+      const scope = rawScope === 'flag' || rawScope === undefined ? 'user' : rawScope;
+      failedPluginItems.push({
+        type: 'failed-plugin',
+        id: pluginId_0,
+        name: pluginName_0,
+        marketplace,
+        scope,
+        errorCount: errors_0.length,
+        errors: errors_0
+      });
+    }
+
+    // Build standalone MCP items
+    const standaloneMcps: UnifiedInstalledItem[] = [];
+    for (const client_1 of mcpClients) {
+      if (client_1.name === 'ide') continue;
+      if (client_1.name.startsWith('plugin:')) continue;
+      standaloneMcps.push({
+        type: 'mcp',
+        id: `mcp:${client_1.name}`,
+        name: client_1.name,
+        description: undefined,
+        scope: client_1.config.scope,
+        status: getMcpStatus(client_1),
+        client: client_1
+      });
+    }
+
+    // Define scope order for display
+    const scopeOrder: Record<string, number> = {
+      flagged: -1,
+      project: 0,
+      local: 1,
+      user: 2,
+      enterprise: 3,
+      managed: 4,
+      dynamic: 5,
+      builtin: 6
+    };
+
+    // Build final list by merging plugins (with their child MCPs) and standalone MCPs
+    // Group by scope to avoid duplicate scope headers
+    const unified: UnifiedInstalledItem[] = [];
+
+    // Create a map of scope -> items for proper merging
+    const itemsByScope = new Map<string, UnifiedInstalledItem[]>();
+
+    // Add plugins with their child MCPs
+    for (const {
+      item: item_1,
+      originalScope: originalScope_0,
+      childMcps
+    } of pluginsWithChildren) {
+      const scope_0 = item_1.scope;
+      if (!itemsByScope.has(scope_0)) {
+        itemsByScope.set(scope_0, []);
+      }
+      itemsByScope.get(scope_0)!.push(item_1);
+      // Add child MCPs right after the plugin, indented (use original scope, not 'flagged').
+      // Built-in plugins map to 'user' for display since MCP ConfigScope doesn't include 'builtin'.
+      for (const {
+        displayName,
+        client: client_2
+      } of childMcps) {
+        const displayScope = originalScope_0 === 'builtin' ? 'user' : originalScope_0;
+        if (!itemsByScope.has(displayScope)) {
+          itemsByScope.set(displayScope, []);
+        }
+        itemsByScope.get(displayScope)!.push({
+          type: 'mcp',
+          id: `mcp:${client_2.name}`,
+          name: displayName,
+          description: undefined,
+          scope: displayScope,
+          status: getMcpStatus(client_2),
+          client: client_2,
+          indented: true
+        });
+      }
+    }
+
+    // Add standalone MCPs to their respective scope groups
+    for (const mcp of standaloneMcps) {
+      const scope_1 = mcp.scope;
+      if (!itemsByScope.has(scope_1)) {
+        itemsByScope.set(scope_1, []);
+      }
+      itemsByScope.get(scope_1)!.push(mcp);
+    }
+
+    // Add failed plugins to their respective scope groups
+    for (const failedPlugin of failedPluginItems) {
+      const scope_2 = failedPlugin.scope;
+      if (!itemsByScope.has(scope_2)) {
+        itemsByScope.set(scope_2, []);
+      }
+      itemsByScope.get(scope_2)!.push(failedPlugin);
+    }
+
+    // Add flagged (delisted) plugins from user settings.
+    // Reason/text are looked up from the cached security messages file.
+    for (const [pluginId_1, entry] of Object.entries(flaggedPlugins)) {
+      const parsed_0 = parsePluginIdentifier(pluginId_1);
+      const pluginName_1 = parsed_0.name || pluginId_1;
+      const marketplace_0 = parsed_0.marketplace || 'unknown';
+      if (!itemsByScope.has('flagged')) {
+        itemsByScope.set('flagged', []);
+      }
+      itemsByScope.get('flagged')!.push({
+        type: 'flagged-plugin',
+        id: pluginId_1,
+        name: pluginName_1,
+        marketplace: marketplace_0,
+        scope: 'flagged',
+        reason: 'delisted',
+        text: 'Removed from marketplace',
+        flaggedAt: entry.flaggedAt
+      });
+    }
+
+    // Sort scopes and build final list
+    const sortedScopes = [...itemsByScope.keys()].sort((a, b) => (scopeOrder[a] ?? 99) - (scopeOrder[b] ?? 99));
+    for (const scope_3 of sortedScopes) {
+      const items = itemsByScope.get(scope_3)!;
+
+      // Separate items into plugin groups (with their child MCPs) and standalone MCPs
+      // This preserves parent-child relationships that would be broken by naive sorting
+      const pluginGroups: UnifiedInstalledItem[][] = [];
+      const standaloneMcpsInScope: UnifiedInstalledItem[] = [];
+      let i = 0;
+      while (i < items.length) {
+        const item_2 = items[i]!;
+        if (item_2.type === 'plugin' || item_2.type === 'failed-plugin' || item_2.type === 'flagged-plugin') {
+          // Collect the plugin and its child MCPs as a group
+          const group: UnifiedInstalledItem[] = [item_2];
+          i++;
+          // Look ahead for indented child MCPs
+          let nextItem = items[i];
+          while (nextItem?.type === 'mcp' && nextItem.indented) {
+            group.push(nextItem);
+            i++;
+            nextItem = items[i];
+          }
+          pluginGroups.push(group);
+        } else if (item_2.type === 'mcp' && !item_2.indented) {
+          // Standalone MCP (not a child of a plugin)
+          standaloneMcpsInScope.push(item_2);
+          i++;
+        } else {
+          // Skip orphaned indented MCPs (shouldn't happen)
+          i++;
+        }
+      }
+
+      // Sort plugin groups by the plugin name (first item in each group)
+      pluginGroups.sort((a_0, b_0) => a_0[0]!.name.localeCompare(b_0[0]!.name));
+
+      // Sort standalone MCPs by name
+      standaloneMcpsInScope.sort((a_1, b_1) => a_1.name.localeCompare(b_1.name));
+
+      // Build final list: plugins (with their children) first, then standalone MCPs
+      for (const group_0 of pluginGroups) {
+        unified.push(...group_0);
+      }
+      unified.push(...standaloneMcpsInScope);
+    }
+    return unified;
+  }, [pluginStates, mcpClients, pluginErrors, pendingToggles, flaggedPlugins]);
+
+  // Mark flagged plugins as seen when the Installed view renders them.
+  // After 48 hours from seenAt, they auto-clear on next load.
+  const flaggedIds = useMemo(() => unifiedItems.filter(item_3 => item_3.type === 'flagged-plugin').map(item_4 => item_4.id), [unifiedItems]);
+  useEffect(() => {
+    if (flaggedIds.length > 0) {
+      void markFlaggedPluginsSeen(flaggedIds);
+    }
+  }, [flaggedIds]);
+
+  // Filter items based on search query (matches name or description)
+  const filteredItems = useMemo(() => {
+    if (!searchQuery) return unifiedItems;
+    const lowerQuery = searchQuery.toLowerCase();
+    return unifiedItems.filter(item_5 => item_5.name.toLowerCase().includes(lowerQuery) || 'description' in item_5 && item_5.description?.toLowerCase().includes(lowerQuery));
+  }, [unifiedItems, searchQuery]);
+
+  // Selection state
+  const [selectedIndex, setSelectedIndex] = useState(0);
+
+  // Pagination for unified list (continuous scrolling)
+  const pagination = usePagination<UnifiedInstalledItem>({
+    totalItems: filteredItems.length,
+    selectedIndex,
+    maxVisible: 8
+  });
+
+  // Details view state
+  const [detailsMenuIndex, setDetailsMenuIndex] = useState(0);
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [processError, setProcessError] = useState<string | null>(null);
+
+  // Configuration state
+  const [configNeeded, setConfigNeeded] = useState<McpbNeedsConfigResult | null>(null);
+  const [_isLoadingConfig, setIsLoadingConfig] = useState(false);
+  const [selectedPluginHasMcpb, setSelectedPluginHasMcpb] = useState(false);
+
+  // Detect if selected plugin has MCPB
+  // Reads raw marketplace.json to work with old cached marketplaces
+  useEffect(() => {
+    if (!selectedPlugin) {
+      setSelectedPluginHasMcpb(false);
+      return;
+    }
+    async function detectMcpb() {
+      // Check plugin manifest first
+      const mcpServersSpec = selectedPlugin!.plugin.manifest.mcpServers;
+      let hasMcpb = false;
+      if (mcpServersSpec) {
+        hasMcpb = typeof mcpServersSpec === 'string' && isMcpbSource(mcpServersSpec) || Array.isArray(mcpServersSpec) && mcpServersSpec.some(s_2 => typeof s_2 === 'string' && isMcpbSource(s_2));
+      }
+
+      // If not in manifest, read raw marketplace.json directly (bypassing schema validation)
+      // This works even with old cached marketplaces from before MCPB support
+      if (!hasMcpb) {
+        try {
+          const marketplaceDir = path.join(selectedPlugin!.plugin.path, '..');
+          const marketplaceJsonPath = path.join(marketplaceDir, '.claude-plugin', 'marketplace.json');
+          const content = await fs.readFile(marketplaceJsonPath, 'utf-8');
+          const marketplace_1 = jsonParse(content);
+          const entry_0 = marketplace_1.plugins?.find((p: {
+            name: string;
+          }) => p.name === selectedPlugin!.plugin.name);
+          if (entry_0?.mcpServers) {
+            const spec = entry_0.mcpServers;
+            hasMcpb = typeof spec === 'string' && isMcpbSource(spec) || Array.isArray(spec) && spec.some((s_3: unknown) => typeof s_3 === 'string' && isMcpbSource(s_3));
+          }
+        } catch (err) {
+          logForDebugging(`Failed to read raw marketplace.json: ${err}`);
+        }
+      }
+      setSelectedPluginHasMcpb(hasMcpb);
+    }
+    void detectMcpb();
+  }, [selectedPlugin]);
+
+  // Load installed plugins grouped by marketplace
+  useEffect(() => {
+    async function loadInstalledPlugins() {
+      setLoading(true);
+      try {
+        const {
+          enabled,
+          disabled
+        } = await loadAllPlugins();
+        const mergedSettings = getSettings_DEPRECATED(); // Use merged settings to respect all layers
+
+        const allPlugins = filterManagedDisabledPlugins([...enabled, ...disabled]);
+
+        // Group plugins by marketplace
+        const pluginsByMarketplace: Record<string, LoadedPlugin[]> = {};
+        for (const plugin of allPlugins) {
+          const marketplace = plugin.source.split('@')[1] || 'local';
+          if (!pluginsByMarketplace[marketplace]) {
+            pluginsByMarketplace[marketplace] = [];
+          }
+          pluginsByMarketplace[marketplace]!.push(plugin);
+        }
+
+        // Create marketplace info array with enabled/disabled counts
+        const marketplaceInfos: MarketplaceInfo[] = [];
+        for (const [name, plugins] of Object.entries(pluginsByMarketplace)) {
+          const enabledCount = count(plugins, p => {
+            const pluginId = `${p.name}@${name}`;
+            return mergedSettings?.enabledPlugins?.[pluginId] !== false;
+          });
+          const disabledCount = plugins.length - enabledCount;
+          marketplaceInfos.push({
+            name,
+            installedPlugins: plugins,
+            enabledCount,
+            disabledCount
+          });
+        }
+
+        // Sort marketplaces: claude-plugin-directory first, then alphabetically
+        marketplaceInfos.sort((a, b) => {
+          if (a.name === 'claude-plugin-directory') return -1;
+          if (b.name === 'claude-plugin-directory') return 1;
+          return a.name.localeCompare(b.name);
+        });
+        setMarketplaces(marketplaceInfos);
+
+        // Build flat list of all plugin states
+        const allStates: PluginState[] = [];
+        for (const marketplace of marketplaceInfos) {
+          for (const plugin of marketplace.installedPlugins) {
+            const pluginId = `${plugin.name}@${marketplace.name}`;
+            // Built-in plugins don't have V2 install entries — skip the lookup.
+            const scope = plugin.isBuiltin ? 'builtin' : getPluginInstallationFromV2(pluginId).scope;
+            allStates.push({
+              plugin,
+              marketplace: marketplace.name,
+              scope,
+              pendingEnable: undefined,
+              pendingUpdate: false
+            });
+          }
+        }
+        setPluginStates(allStates);
+        setSelectedIndex(0);
+      } finally {
+        setLoading(false);
+      }
+    }
+    void loadInstalledPlugins();
+  }, []);
+
+  // Auto-navigate to target plugin if specified (once only)
+  useEffect(() => {
+    if (hasAutoNavigated.current) return;
+    if (targetPlugin && marketplaces.length > 0 && !loading) {
+      // targetPlugin may be `name` or `name@marketplace` (parseArgs passes the
+      // raw arg through). Parse it so p.name matching works either way.
+      const {
+        name: targetName,
+        marketplace: targetMktFromId
+      } = parsePluginIdentifier(targetPlugin);
+      const effectiveTargetMarketplace = targetMarketplace ?? targetMktFromId;
+
+      // Use targetMarketplace if provided, otherwise search all
+      const marketplacesToSearch = effectiveTargetMarketplace ? marketplaces.filter(m => m.name === effectiveTargetMarketplace) : marketplaces;
+
+      // First check successfully loaded plugins
+      for (const marketplace_2 of marketplacesToSearch) {
+        const plugin = marketplace_2.installedPlugins.find(p_0 => p_0.name === targetName);
+        if (plugin) {
+          // Get scope from V2 data for proper operation handling
+          const pluginId_2 = `${plugin.name}@${marketplace_2.name}`;
+          const {
+            scope: scope_4
+          } = getPluginInstallationFromV2(pluginId_2);
+          const pluginState: PluginState = {
+            plugin,
+            marketplace: marketplace_2.name,
+            scope: scope_4,
+            pendingEnable: undefined,
+            pendingUpdate: false
+          };
+          setSelectedPlugin(pluginState);
+          setViewState('plugin-details');
+          pendingAutoActionRef.current = action;
+          hasAutoNavigated.current = true;
+          return;
+        }
+      }
+
+      // Fall back to failed plugins (those with errors but not loaded)
+      const failedItem = unifiedItems.find(item_6 => item_6.type === 'failed-plugin' && item_6.name === targetName);
+      if (failedItem && failedItem.type === 'failed-plugin') {
+        setViewState({
+          type: 'failed-plugin-details',
+          plugin: {
+            id: failedItem.id,
+            name: failedItem.name,
+            marketplace: failedItem.marketplace,
+            errors: failedItem.errors,
+            scope: failedItem.scope
+          }
+        });
+        hasAutoNavigated.current = true;
+      }
+
+      // No match in loaded OR failed plugins — close the dialog with a
+      // message rather than silently landing on the plugin list. Only do
+      // this when an action was requested (e.g. /plugin uninstall X);
+      // plain navigation (/plugin manage) should still just show the list.
+      if (!hasAutoNavigated.current && action) {
+        hasAutoNavigated.current = true;
+        setResult(`Plugin "${targetPlugin}" is not installed in this project`);
+      }
+    }
+  }, [targetPlugin, targetMarketplace, marketplaces, loading, unifiedItems, action, setResult]);
+
+  // Handle single plugin operations from details view
+  const handleSingleOperation = async (operation: 'enable' | 'disable' | 'update' | 'uninstall') => {
+    if (!selectedPlugin) return;
+    const pluginScope = selectedPlugin.scope || 'user';
+    const isBuiltin = pluginScope === 'builtin';
+
+    // Built-in plugins can only be enabled/disabled, not updated/uninstalled.
+    if (isBuiltin && (operation === 'update' || operation === 'uninstall')) {
+      setProcessError('Built-in plugins cannot be updated or uninstalled.');
+      return;
+    }
+
+    // Managed scope plugins can only be updated, not enabled/disabled/uninstalled
+    if (!isBuiltin && !isInstallableScope(pluginScope) && operation !== 'update') {
+      setProcessError('This plugin is managed by your organization. Contact your admin to disable it.');
+      return;
+    }
+    setIsProcessing(true);
+    setProcessError(null);
+    try {
+      const pluginId_3 = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`;
+      let reverseDependents: string[] | undefined;
+
+      // enable/disable omit scope — pluginScope is the install scope from
+      // installed_plugins.json (where files are cached), which can diverge
+      // from the settings scope (where enablement lives). Passing it trips
+      // the cross-scope guard. Auto-detect finds the right scope. #38084
+      switch (operation) {
+        case 'enable':
+          {
+            const enableResult = await enablePluginOp(pluginId_3);
+            if (!enableResult.success) {
+              throw new Error(enableResult.message);
+            }
+            break;
+          }
+        case 'disable':
+          {
+            const disableResult = await disablePluginOp(pluginId_3);
+            if (!disableResult.success) {
+              throw new Error(disableResult.message);
+            }
+            reverseDependents = disableResult.reverseDependents;
+            break;
+          }
+        case 'uninstall':
+          {
+            if (isBuiltin) break; // guarded above; narrows pluginScope
+            if (!isInstallableScope(pluginScope)) break;
+            // If the plugin is enabled in .claude/settings.json (shared with the
+            // team), divert to a confirmation dialog that offers to disable in
+            // settings.local.json instead. Check the settings file directly —
+            // `pluginScope` (from installed_plugins.json) can be 'user' even when
+            // the plugin is ALSO project-enabled, and uninstalling the user-scope
+            // install would leave the project enablement active.
+            if (isPluginEnabledAtProjectScope(pluginId_3)) {
+              setIsProcessing(false);
+              setViewState('confirm-project-uninstall');
+              return;
+            }
+            // If the plugin has persistent data (${CLAUDE_PLUGIN_DATA}) AND this
+            // is the last scope, prompt before deleting it. For multi-scope
+            // installs, the op's isLastScope check won't delete regardless of
+            // the user's y/n — showing the dialog would mislead ("y" → nothing
+            // happens). Length check mirrors pluginOperations.ts:513.
+            const installs = loadInstalledPluginsV2().plugins[pluginId_3];
+            const isLastScope = !installs || installs.length <= 1;
+            const dataSize = isLastScope ? await getPluginDataDirSize(pluginId_3) : null;
+            if (dataSize) {
+              setIsProcessing(false);
+              setViewState({
+                type: 'confirm-data-cleanup',
+                size: dataSize
+              });
+              return;
+            }
+            const result_0 = await uninstallPluginOp(pluginId_3, pluginScope);
+            if (!result_0.success) {
+              throw new Error(result_0.message);
+            }
+            reverseDependents = result_0.reverseDependents;
+            break;
+          }
+        case 'update':
+          {
+            if (isBuiltin) break; // guarded above; narrows pluginScope
+            const result = await updatePluginOp(pluginId_3, pluginScope);
+            if (!result.success) {
+              throw new Error(result.message);
+            }
+            // If already up to date, show message and exit
+            if (result.alreadyUpToDate) {
+              setResult(`${selectedPlugin.plugin.name} is already at the latest version (${result.newVersion}).`);
+              if (onManageComplete) {
+                await onManageComplete();
+              }
+              setParentViewState({
+                type: 'menu'
+              });
+              return;
+            }
+            // Success - will show standard message below
+            break;
+          }
+      }
+
+      // Operations (enable, disable, uninstall, update) now use centralized functions
+      // that handle their own settings updates, so we only need to clear caches here
+      clearAllCaches();
+
+      // Prompt for manifest.userConfig + channel userConfig if the plugin ends
+      // up enabled. Re-read settings rather than keying on `operation ===
+      // 'enable'`: install enables on install, so the menu shows "Disable"
+      // first. PluginOptionsFlow itself checks getUnconfiguredOptions — if
+      // nothing needs filling, it calls onDone('skipped') immediately.
+      const pluginIdNow = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`;
+      const settingsAfter = getSettings_DEPRECATED();
+      const enabledAfter = settingsAfter?.enabledPlugins?.[pluginIdNow] !== false;
+      if (enabledAfter) {
+        setIsProcessing(false);
+        setViewState({
+          type: 'plugin-options'
+        });
+        return;
+      }
+      const operationName = operation === 'enable' ? 'Enabled' : operation === 'disable' ? 'Disabled' : operation === 'update' ? 'Updated' : 'Uninstalled';
+
+      // Single-line warning — notification timeout is ~8s, multi-line would scroll off.
+      // The persistent record is in the Errors tab (dependency-unsatisfied after reload).
+      const depWarn = reverseDependents && reverseDependents.length > 0 ? ` · required by ${reverseDependents.join(', ')}` : '';
+      const message = `✓ ${operationName} ${selectedPlugin.plugin.name}${depWarn}. Run /reload-plugins to apply.`;
+      setResult(message);
+      if (onManageComplete) {
+        await onManageComplete();
+      }
+      setParentViewState({
+        type: 'menu'
+      });
+    } catch (error_0) {
+      setIsProcessing(false);
+      const errorMessage = error_0 instanceof Error ? error_0.message : String(error_0);
+      setProcessError(`Failed to ${operation}: ${errorMessage}`);
+      logError(toError(error_0));
+    }
+  };
+
+  // Latest-ref: lets the auto-action effect call the current closure without
+  // adding handleSingleOperation (recreated every render) to its deps.
+  const handleSingleOperationRef = useRef(handleSingleOperation);
+  handleSingleOperationRef.current = handleSingleOperation;
+
+  // Auto-execute the action prop (/plugin uninstall X, /plugin enable X, etc.)
+  // once auto-navigation has landed on plugin-details.
+  useEffect(() => {
+    if (viewState === 'plugin-details' && selectedPlugin && pendingAutoActionRef.current) {
+      const pending = pendingAutoActionRef.current;
+      pendingAutoActionRef.current = undefined;
+      void handleSingleOperationRef.current(pending);
+    }
+  }, [viewState, selectedPlugin]);
+
+  // Handle toggle enable/disable
+  const handleToggle = React.useCallback(() => {
+    if (selectedIndex >= filteredItems.length) return;
+    const item_7 = filteredItems[selectedIndex];
+    if (item_7?.type === 'flagged-plugin') return;
+    if (item_7?.type === 'plugin') {
+      const pluginId_4 = `${item_7.plugin.name}@${item_7.marketplace}`;
+      const mergedSettings_0 = getSettings_DEPRECATED();
+      const currentPending = pendingToggles.get(pluginId_4);
+      const isEnabled_0 = mergedSettings_0?.enabledPlugins?.[pluginId_4] !== false;
+      const pluginScope_0 = item_7.scope;
+      const isBuiltin_0 = pluginScope_0 === 'builtin';
+      if (isBuiltin_0 || isInstallableScope(pluginScope_0)) {
+        const newPending = new Map(pendingToggles);
+        // Omit scope — see handleSingleOperation's enable/disable comment.
+        if (currentPending) {
+          // Cancel: reverse the operation back to the original state
+          newPending.delete(pluginId_4);
+          void (async () => {
+            try {
+              if (currentPending === 'will-disable') {
+                await enablePluginOp(pluginId_4);
+              } else {
+                await disablePluginOp(pluginId_4);
+              }
+              clearAllCaches();
+            } catch (err_0) {
+              logError(err_0);
+            }
+          })();
+        } else {
+          newPending.set(pluginId_4, isEnabled_0 ? 'will-disable' : 'will-enable');
+          void (async () => {
+            try {
+              if (isEnabled_0) {
+                await disablePluginOp(pluginId_4);
+              } else {
+                await enablePluginOp(pluginId_4);
+              }
+              clearAllCaches();
+            } catch (err_1) {
+              logError(err_1);
+            }
+          })();
+        }
+        setPendingToggles(newPending);
+      }
+    } else if (item_7?.type === 'mcp') {
+      void toggleMcpServer(item_7.client.name);
+    }
+  }, [selectedIndex, filteredItems, pendingToggles, pluginStates, toggleMcpServer]);
+
+  // Handle accept (Enter) in plugin-list
+  const handleAccept = React.useCallback(() => {
+    if (selectedIndex >= filteredItems.length) return;
+    const item_8 = filteredItems[selectedIndex];
+    if (item_8?.type === 'plugin') {
+      const state_0 = pluginStates.find(s_4 => s_4.plugin.name === item_8.plugin.name && s_4.marketplace === item_8.marketplace);
+      if (state_0) {
+        setSelectedPlugin(state_0);
+        setViewState('plugin-details');
+        setDetailsMenuIndex(0);
+        setProcessError(null);
+      }
+    } else if (item_8?.type === 'flagged-plugin') {
+      setViewState({
+        type: 'flagged-detail',
+        plugin: {
+          id: item_8.id,
+          name: item_8.name,
+          marketplace: item_8.marketplace,
+          reason: item_8.reason,
+          text: item_8.text,
+          flaggedAt: item_8.flaggedAt
+        }
+      });
+      setProcessError(null);
+    } else if (item_8?.type === 'failed-plugin') {
+      setViewState({
+        type: 'failed-plugin-details',
+        plugin: {
+          id: item_8.id,
+          name: item_8.name,
+          marketplace: item_8.marketplace,
+          errors: item_8.errors,
+          scope: item_8.scope
+        }
+      });
+      setDetailsMenuIndex(0);
+      setProcessError(null);
+    } else if (item_8?.type === 'mcp') {
+      setViewState({
+        type: 'mcp-detail',
+        client: item_8.client
+      });
+      setProcessError(null);
+    }
+  }, [selectedIndex, filteredItems, pluginStates]);
+
+  // Plugin-list navigation (non-search mode)
+  useKeybindings({
+    'select:previous': () => {
+      if (selectedIndex === 0) {
+        setIsSearchMode(true);
+      } else {
+        pagination.handleSelectionChange(selectedIndex - 1, setSelectedIndex);
+      }
+    },
+    'select:next': () => {
+      if (selectedIndex < filteredItems.length - 1) {
+        pagination.handleSelectionChange(selectedIndex + 1, setSelectedIndex);
+      }
+    },
+    'select:accept': handleAccept
+  }, {
+    context: 'Select',
+    isActive: viewState === 'plugin-list' && !isSearchMode
+  });
+  useKeybindings({
+    'plugin:toggle': handleToggle
+  }, {
+    context: 'Plugin',
+    isActive: viewState === 'plugin-list' && !isSearchMode
+  });
+
+  // Handle dismiss action in flagged-detail view
+  const handleFlaggedDismiss = React.useCallback(() => {
+    if (typeof viewState !== 'object' || viewState.type !== 'flagged-detail') return;
+    void removeFlaggedPlugin(viewState.plugin.id);
+    setViewState('plugin-list');
+  }, [viewState]);
+  useKeybindings({
+    'select:accept': handleFlaggedDismiss
+  }, {
+    context: 'Select',
+    isActive: typeof viewState === 'object' && viewState.type === 'flagged-detail'
+  });
+
+  // Build details menu items (needed for navigation)
+  const detailsMenuItems = React.useMemo(() => {
+    if (viewState !== 'plugin-details' || !selectedPlugin) return [];
+    const mergedSettings_1 = getSettings_DEPRECATED();
+    const pluginId_5 = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`;
+    const isEnabled_1 = mergedSettings_1?.enabledPlugins?.[pluginId_5] !== false;
+    const isBuiltin_1 = selectedPlugin.marketplace === 'builtin';
+    const menuItems: Array<{
+      label: string;
+      action: () => void;
+    }> = [];
+    menuItems.push({
+      label: isEnabled_1 ? 'Disable plugin' : 'Enable plugin',
+      action: () => void handleSingleOperation(isEnabled_1 ? 'disable' : 'enable')
+    });
+
+    // Update/Uninstall options — not available for built-in plugins
+    if (!isBuiltin_1) {
+      menuItems.push({
+        label: selectedPlugin.pendingUpdate ? 'Unmark for update' : 'Mark for update',
+        action: async () => {
+          try {
+            const localError = await checkIfLocalPlugin(selectedPlugin.plugin.name, selectedPlugin.marketplace);
+            if (localError) {
+              setProcessError(localError);
+              return;
+            }
+            const newStates = [...pluginStates];
+            const index = newStates.findIndex(s_5 => s_5.plugin.name === selectedPlugin.plugin.name && s_5.marketplace === selectedPlugin.marketplace);
+            if (index !== -1) {
+              newStates[index]!.pendingUpdate = !selectedPlugin.pendingUpdate;
+              setPluginStates(newStates);
+              setSelectedPlugin({
+                ...selectedPlugin,
+                pendingUpdate: !selectedPlugin.pendingUpdate
+              });
+            }
+          } catch (error_1) {
+            setProcessError(error_1 instanceof Error ? error_1.message : 'Failed to check plugin update availability');
+          }
+        }
+      });
+      if (selectedPluginHasMcpb) {
+        menuItems.push({
+          label: 'Configure',
+          action: async () => {
+            setIsLoadingConfig(true);
+            try {
+              const mcpServersSpec_0 = selectedPlugin.plugin.manifest.mcpServers;
+              let mcpbPath: string | null = null;
+              if (typeof mcpServersSpec_0 === 'string' && isMcpbSource(mcpServersSpec_0)) {
+                mcpbPath = mcpServersSpec_0;
+              } else if (Array.isArray(mcpServersSpec_0)) {
+                for (const spec_0 of mcpServersSpec_0) {
+                  if (typeof spec_0 === 'string' && isMcpbSource(spec_0)) {
+                    mcpbPath = spec_0;
+                    break;
+                  }
+                }
+              }
+              if (!mcpbPath) {
+                setProcessError('No MCPB file found in plugin');
+                setIsLoadingConfig(false);
+                return;
+              }
+              const pluginId_6 = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`;
+              const result_1 = await loadMcpbFile(mcpbPath, selectedPlugin.plugin.path, pluginId_6, undefined, undefined, true);
+              if ('status' in result_1 && result_1.status === 'needs-config') {
+                setConfigNeeded(result_1);
+                setViewState('configuring');
+              } else {
+                setProcessError('Failed to load MCPB for configuration');
+              }
+            } catch (err_2) {
+              const errorMsg = errorMessage(err_2);
+              setProcessError(`Failed to load configuration: ${errorMsg}`);
+            } finally {
+              setIsLoadingConfig(false);
+            }
+          }
+        });
+      }
+      if (selectedPlugin.plugin.manifest.userConfig && Object.keys(selectedPlugin.plugin.manifest.userConfig).length > 0) {
+        menuItems.push({
+          label: 'Configure options',
+          action: () => {
+            setViewState({
+              type: 'configuring-options',
+              schema: selectedPlugin.plugin.manifest.userConfig!
+            });
+          }
+        });
+      }
+      menuItems.push({
+        label: 'Update now',
+        action: () => void handleSingleOperation('update')
+      });
+      menuItems.push({
+        label: 'Uninstall',
+        action: () => void handleSingleOperation('uninstall')
+      });
+    }
+    if (selectedPlugin.plugin.manifest.homepage) {
+      menuItems.push({
+        label: 'Open homepage',
+        action: () => void openBrowser(selectedPlugin.plugin.manifest.homepage!)
+      });
+    }
+    if (selectedPlugin.plugin.manifest.repository) {
+      menuItems.push({
+        // Generic label — manifest.repository can be GitLab, Bitbucket,
+        // Azure DevOps, etc. (gh-31598). pluginDetailsHelpers.tsx:74 keeps
+        // 'View on GitHub' because that path has an explicit isGitHub check.
+        label: 'View repository',
+        action: () => void openBrowser(selectedPlugin.plugin.manifest.repository!)
+      });
+    }
+    menuItems.push({
+      label: 'Back to plugin list',
+      action: () => {
+        setViewState('plugin-list');
+        setSelectedPlugin(null);
+        setProcessError(null);
+      }
+    });
+    return menuItems;
+  }, [viewState, selectedPlugin, selectedPluginHasMcpb, pluginStates]);
+
+  // Plugin-details navigation
+  useKeybindings({
+    'select:previous': () => {
+      if (detailsMenuIndex > 0) {
+        setDetailsMenuIndex(detailsMenuIndex - 1);
+      }
+    },
+    'select:next': () => {
+      if (detailsMenuIndex < detailsMenuItems.length - 1) {
+        setDetailsMenuIndex(detailsMenuIndex + 1);
+      }
+    },
+    'select:accept': () => {
+      if (detailsMenuItems[detailsMenuIndex]) {
+        detailsMenuItems[detailsMenuIndex]!.action();
+      }
+    }
+  }, {
+    context: 'Select',
+    isActive: viewState === 'plugin-details' && !!selectedPlugin
+  });
+
+  // Failed-plugin-details: only "Uninstall" option, handle Enter
+  useKeybindings({
+    'select:accept': () => {
+      if (typeof viewState === 'object' && viewState.type === 'failed-plugin-details') {
+        void (async () => {
+          setIsProcessing(true);
+          setProcessError(null);
+          const pluginId_7 = viewState.plugin.id;
+          const pluginScope_1 = viewState.plugin.scope;
+          // Pass scope to uninstallPluginOp so it can find the correct V2
+          // installation record and clean up on-disk files. Fall back to
+          // default scope if not installable (e.g. 'managed', though that
+          // case is guarded by isActive below). deleteDataDir=false: this
+          // is a recovery path for a plugin that failed to load — it may
+          // be reinstallable, so don't nuke ${CLAUDE_PLUGIN_DATA} silently.
+          // The normal uninstall path prompts; this one preserves.
+          const result_2 = isInstallableScope(pluginScope_1) ? await uninstallPluginOp(pluginId_7, pluginScope_1, false) : await uninstallPluginOp(pluginId_7, 'user', false);
+          let success = result_2.success;
+          if (!success) {
+            // Plugin was never installed (only in enabledPlugins settings).
+            // Remove directly from all editable settings sources.
+            const editableSources = ['userSettings' as const, 'projectSettings' as const, 'localSettings' as const];
+            for (const source of editableSources) {
+              const settings = getSettingsForSource(source);
+              if (settings?.enabledPlugins?.[pluginId_7] !== undefined) {
+                updateSettingsForSource(source, {
+                  enabledPlugins: {
+                    ...settings.enabledPlugins,
+                    [pluginId_7]: undefined
+                  }
+                });
+                success = true;
+              }
+            }
+            // Clear memoized caches so next loadAllPlugins() picks up settings changes
+            clearAllCaches();
+          }
+          if (success) {
+            if (onManageComplete) {
+              await onManageComplete();
+            }
+            setIsProcessing(false);
+            // Return to list (don't setResult — that closes the whole dialog)
+            setViewState('plugin-list');
+          } else {
+            setIsProcessing(false);
+            setProcessError(result_2.message);
+          }
+        })();
+      }
+    }
+  }, {
+    context: 'Select',
+    isActive: typeof viewState === 'object' && viewState.type === 'failed-plugin-details' && viewState.plugin.scope !== 'managed'
+  });
+
+  // Confirm-project-uninstall: y/enter disables in settings.local.json, n/escape cancels
+  useKeybindings({
+    'confirm:yes': () => {
+      if (!selectedPlugin) return;
+      setIsProcessing(true);
+      setProcessError(null);
+      const pluginId_8 = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`;
+      // Write `false` directly — disablePluginOp's cross-scope guard would
+      // reject this (plugin isn't in localSettings yet; the override IS the
+      // point).
+      const {
+        error: error_2
+      } = updateSettingsForSource('localSettings', {
+        enabledPlugins: {
+          ...getSettingsForSource('localSettings')?.enabledPlugins,
+          [pluginId_8]: false
+        }
+      });
+      if (error_2) {
+        setIsProcessing(false);
+        setProcessError(`Failed to write settings: ${error_2.message}`);
+        return;
+      }
+      clearAllCaches();
+      setResult(`✓ Disabled ${selectedPlugin.plugin.name} in .claude/settings.local.json. Run /reload-plugins to apply.`);
+      if (onManageComplete) void onManageComplete();
+      setParentViewState({
+        type: 'menu'
+      });
+    },
+    'confirm:no': () => {
+      setViewState('plugin-details');
+      setProcessError(null);
+    }
+  }, {
+    context: 'Confirmation',
+    isActive: viewState === 'confirm-project-uninstall' && !!selectedPlugin && !isProcessing
+  });
+
+  // Confirm-data-cleanup: y uninstalls + deletes data dir, n uninstalls + keeps,
+  // esc cancels. Raw useInput because: (1) the Confirmation context maps
+  // enter→confirm:yes, which would make Enter delete the data directory — a
+  // destructive default the UI text ("y to delete · n to keep") doesn't
+  // advertise; (2) unlike confirm-project-uninstall (which uses useKeybindings
+  // where n and escape both map to confirm:no), here n and escape are DIFFERENT
+  // actions (keep-data vs cancel), so this deliberately stays on raw useInput.
+  // eslint-disable-next-line custom-rules/prefer-use-keybindings -- raw y/n/esc; Enter must not trigger destructive delete
+  useInput((input, key) => {
+    if (!selectedPlugin) return;
+    const pluginId_9 = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`;
+    const pluginScope_2 = selectedPlugin.scope;
+    // Dialog is only reachable from the uninstall case (which guards on
+    // isBuiltin), but TS can't track that across viewState transitions.
+    if (!pluginScope_2 || pluginScope_2 === 'builtin' || !isInstallableScope(pluginScope_2)) return;
+    const doUninstall = async (deleteDataDir: boolean) => {
+      setIsProcessing(true);
+      setProcessError(null);
+      try {
+        const result_3 = await uninstallPluginOp(pluginId_9, pluginScope_2, deleteDataDir);
+        if (!result_3.success) throw new Error(result_3.message);
+        clearAllCaches();
+        const suffix = deleteDataDir ? '' : ' · data preserved';
+        setResult(`${figures.tick} ${result_3.message}${suffix}`);
+        if (onManageComplete) void onManageComplete();
+        setParentViewState({
+          type: 'menu'
+        });
+      } catch (e_0) {
+        setIsProcessing(false);
+        setProcessError(e_0 instanceof Error ? e_0.message : String(e_0));
+      }
+    };
+    if (input === 'y' || input === 'Y') {
+      void doUninstall(true);
+    } else if (input === 'n' || input === 'N') {
+      void doUninstall(false);
+    } else if (key.escape) {
+      setViewState('plugin-details');
+      setProcessError(null);
+    }
+  }, {
+    isActive: typeof viewState === 'object' && viewState.type === 'confirm-data-cleanup' && !!selectedPlugin && !isProcessing
+  });
+
+  // Reset selection when search query changes
+  React.useEffect(() => {
+    setSelectedIndex(0);
+  }, [searchQuery]);
+
+  // Handle input for entering search mode (text input handled by useSearchInput hook)
+  // eslint-disable-next-line custom-rules/prefer-use-keybindings -- useInput needed for raw search mode text input
+  useInput((input_0, key_0) => {
+    const keyIsNotCtrlOrMeta = !key_0.ctrl && !key_0.meta;
+    if (isSearchMode) {
+      // Text input is handled by useSearchInput hook
+      return;
+    }
+
+    // Enter search mode with '/' or any printable character (except navigation keys)
+    if (input_0 === '/' && keyIsNotCtrlOrMeta) {
+      setIsSearchMode(true);
+      setSearchQuery('');
+      setSelectedIndex(0);
+    } else if (keyIsNotCtrlOrMeta && input_0.length > 0 && !/^\s+$/.test(input_0) && input_0 !== 'j' && input_0 !== 'k' && input_0 !== ' ') {
+      setIsSearchMode(true);
+      setSearchQuery(input_0);
+      setSelectedIndex(0);
+    }
+  }, {
+    isActive: viewState === 'plugin-list'
+  });
+
+  // Loading state
+  if (loading) {
+    return <Text>Loading installed plugins…</Text>;
+  }
+
+  // No plugins or MCPs installed
+  if (unifiedItems.length === 0) {
+    return <Box flexDirection="column">
+        <Box marginBottom={1}>
+          <Text bold>Manage plugins</Text>
+        </Box>
+        <Text>No plugins or MCP servers installed.</Text>
+        <Box marginTop={1}>
+          <Text dimColor>Esc to go back</Text>
+        </Box>
+      </Box>;
+  }
+  if (typeof viewState === 'object' && viewState.type === 'plugin-options' && selectedPlugin) {
+    const pluginId_10 = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`;
+    function finish(msg: string): void {
+      setResult(msg);
+      // Plugin is enabled regardless of whether config was saved or
+      // skipped — onManageComplete → markPluginsChanged → the
+      // persistent "run /reload-plugins" notice.
+      if (onManageComplete) {
+        void onManageComplete();
+      }
+      setParentViewState({
+        type: 'menu'
+      });
+    }
+    return <PluginOptionsFlow plugin={selectedPlugin.plugin} pluginId={pluginId_10} onDone={(outcome, detail) => {
+      switch (outcome) {
+        case 'configured':
+          finish(`✓ Enabled and configured ${selectedPlugin.plugin.name}. Run /reload-plugins to apply.`);
+          break;
+        case 'skipped':
+          finish(`✓ Enabled ${selectedPlugin.plugin.name}. Run /reload-plugins to apply.`);
+          break;
+        case 'error':
+          finish(`Failed to save configuration: ${detail}`);
+          break;
+      }
+    }} />;
+  }
+
+  // Configure options (from the Manage menu)
+  if (typeof viewState === 'object' && viewState.type === 'configuring-options' && selectedPlugin) {
+    const pluginId_11 = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`;
+    return <PluginOptionsDialog title={`Configure ${selectedPlugin.plugin.name}`} subtitle="Plugin options" configSchema={viewState.schema} initialValues={loadPluginOptions(pluginId_11)} onSave={values => {
+      try {
+        savePluginOptions(pluginId_11, values, viewState.schema);
+        clearAllCaches();
+        setResult('Configuration saved. Run /reload-plugins for changes to take effect.');
+      } catch (err_3) {
+        setProcessError(`Failed to save configuration: ${errorMessage(err_3)}`);
+      }
+      setViewState('plugin-details');
+    }} onCancel={() => setViewState('plugin-details')} />;
+  }
+
+  // Configuration view
+  if (viewState === 'configuring' && configNeeded && selectedPlugin) {
+    const pluginId_12 = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`;
+    async function handleSave(config: UserConfigValues) {
+      if (!configNeeded || !selectedPlugin) return;
+      try {
+        // Find MCPB path again
+        const mcpServersSpec_1 = selectedPlugin.plugin.manifest.mcpServers;
+        let mcpbPath_0: string | null = null;
+        if (typeof mcpServersSpec_1 === 'string' && isMcpbSource(mcpServersSpec_1)) {
+          mcpbPath_0 = mcpServersSpec_1;
+        } else if (Array.isArray(mcpServersSpec_1)) {
+          for (const spec_1 of mcpServersSpec_1) {
+            if (typeof spec_1 === 'string' && isMcpbSource(spec_1)) {
+              mcpbPath_0 = spec_1;
+              break;
+            }
+          }
+        }
+        if (!mcpbPath_0) {
+          setProcessError('No MCPB file found');
+          setViewState('plugin-details');
+          return;
+        }
+
+        // Reload with provided config
+        await loadMcpbFile(mcpbPath_0, selectedPlugin.plugin.path, pluginId_12, undefined, config);
+
+        // Success - go back to details
+        setProcessError(null);
+        setConfigNeeded(null);
+        setViewState('plugin-details');
+        setResult('Configuration saved. Run /reload-plugins for changes to take effect.');
+      } catch (err_4) {
+        const errorMsg_0 = errorMessage(err_4);
+        setProcessError(`Failed to save configuration: ${errorMsg_0}`);
+        setViewState('plugin-details');
+      }
+    }
+    function handleCancel() {
+      setConfigNeeded(null);
+      setViewState('plugin-details');
+    }
+    return <PluginOptionsDialog title={`Configure ${configNeeded.manifest.name}`} subtitle={`Plugin: ${selectedPlugin.plugin.name}`} configSchema={configNeeded.configSchema} initialValues={configNeeded.existingConfig} onSave={handleSave} onCancel={handleCancel} />;
+  }
+
+  // Flagged plugin detail view
+  if (typeof viewState === 'object' && viewState.type === 'flagged-detail') {
+    const fp = viewState.plugin;
+    return <Box flexDirection="column">
+        <Box>
+          <Text bold>
+            {fp.name} @ {fp.marketplace}
+          </Text>
+        </Box>
+
+        <Box marginBottom={1}>
+          <Text dimColor>Status: </Text>
+          <Text color="error">Removed</Text>
+        </Box>
+
+        <Box marginBottom={1} flexDirection="column">
+          <Text color="error">
+            Removed from marketplace · reason: {fp.reason}
+          </Text>
+          <Text>{fp.text}</Text>
+          <Text dimColor>
+            Flagged on {new Date(fp.flaggedAt).toLocaleDateString()}
+          </Text>
+        </Box>
+
+        <Box marginTop={1} flexDirection="column">
+          <Box>
+            <Text>{figures.pointer} </Text>
+            <Text color="suggestion">Dismiss</Text>
+          </Box>
+        </Box>
+
+        <Byline>
+          <ConfigurableShortcutHint action="select:accept" context="Select" fallback="Enter" description="dismiss" />
+          <ConfigurableShortcutHint action="confirm:no" context="Confirmation" fallback="Esc" description="back" />
+        </Byline>
+      </Box>;
+  }
+
+  // Confirm-project-uninstall: warn about shared .claude/settings.json,
+  // offer to disable in settings.local.json instead.
+  if (viewState === 'confirm-project-uninstall' && selectedPlugin) {
+    return <Box flexDirection="column">
+        <Text bold color="warning">
+          {selectedPlugin.plugin.name} is enabled in .claude/settings.json
+          (shared with your team)
+        </Text>
+        <Box marginTop={1} flexDirection="column">
+          <Text>Disable it just for you in .claude/settings.local.json?</Text>
+          <Text dimColor>
+            This has the same effect as uninstalling, without affecting other
+            contributors.
+          </Text>
+        </Box>
+        {processError && <Box marginTop={1}>
+            <Text color="error">{processError}</Text>
+          </Box>}
+        <Box marginTop={1}>
+          {isProcessing ? <Text dimColor>Disabling…</Text> : <Byline>
+              <ConfigurableShortcutHint action="confirm:yes" context="Confirmation" fallback="y" description="disable" />
+              <ConfigurableShortcutHint action="confirm:no" context="Confirmation" fallback="Esc" description="cancel" />
+            </Byline>}
+        </Box>
+      </Box>;
+  }
+
+  // Confirm-data-cleanup: prompt before deleting ${CLAUDE_PLUGIN_DATA} dir
+  if (typeof viewState === 'object' && viewState.type === 'confirm-data-cleanup' && selectedPlugin) {
+    return <Box flexDirection="column">
+        <Text bold>
+          {selectedPlugin.plugin.name} has {viewState.size.human} of persistent
+          data
+        </Text>
+        <Box marginTop={1} flexDirection="column">
+          <Text>Delete it along with the plugin?</Text>
+          <Text dimColor>
+            {pluginDataDirPath(`${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`)}
+          </Text>
+        </Box>
+        {processError && <Box marginTop={1}>
+            <Text color="error">{processError}</Text>
+          </Box>}
+        <Box marginTop={1}>
+          {isProcessing ? <Text dimColor>Uninstalling…</Text> : <Text>
+              <Text bold>y</Text> to delete · <Text bold>n</Text> to keep ·{' '}
+              <Text bold>esc</Text> to cancel
+            </Text>}
+        </Box>
+      </Box>;
+  }
+
+  // Plugin details view
+  if (viewState === 'plugin-details' && selectedPlugin) {
+    const mergedSettings_2 = getSettings_DEPRECATED(); // Use merged settings to respect all layers
+    const pluginId_13 = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`;
+    const isEnabled_2 = mergedSettings_2?.enabledPlugins?.[pluginId_13] !== false;
+
+    // Compute plugin errors section
+    const filteredPluginErrors = pluginErrors.filter(e_1 => 'plugin' in e_1 && e_1.plugin === selectedPlugin.plugin.name || e_1.source === pluginId_13 || e_1.source.startsWith(`${selectedPlugin.plugin.name}@`));
+    const pluginErrorsSection = filteredPluginErrors.length === 0 ? null : <Box flexDirection="column" marginBottom={1}>
+          <Text bold color="error">
+            {filteredPluginErrors.length}{' '}
+            {plural(filteredPluginErrors.length, 'error')}:
+          </Text>
+          {filteredPluginErrors.map((error_3, i_0) => {
+        const guidance = getErrorGuidance(error_3);
+        return <Box key={i_0} flexDirection="column" marginLeft={2}>
+                <Text color="error">{formatErrorMessage(error_3)}</Text>
+                {guidance && <Text dimColor italic>
+                    {figures.arrowRight} {guidance}
+                  </Text>}
+              </Box>;
+      })}
+        </Box>;
+    return <Box flexDirection="column">
+        <Box>
+          <Text bold>
+            {selectedPlugin.plugin.name} @ {selectedPlugin.marketplace}
+          </Text>
+        </Box>
+
+        {/* Scope */}
+        <Box>
+          <Text dimColor>Scope: </Text>
+          <Text>{selectedPlugin.scope || 'user'}</Text>
+        </Box>
+
+        {/* Plugin details */}
+        {selectedPlugin.plugin.manifest.version && <Box>
+            <Text dimColor>Version: </Text>
+            <Text>{selectedPlugin.plugin.manifest.version}</Text>
+          </Box>}
+
+        {selectedPlugin.plugin.manifest.description && <Box marginBottom={1}>
+            <Text>{selectedPlugin.plugin.manifest.description}</Text>
+          </Box>}
+
+        {selectedPlugin.plugin.manifest.author && <Box>
+            <Text dimColor>Author: </Text>
+            <Text>{selectedPlugin.plugin.manifest.author.name}</Text>
+          </Box>}
+
+        {/* Current status */}
+        <Box marginBottom={1}>
+          <Text dimColor>Status: </Text>
+          <Text color={isEnabled_2 ? 'success' : 'warning'}>
+            {isEnabled_2 ? 'Enabled' : 'Disabled'}
+          </Text>
+          {selectedPlugin.pendingUpdate && <Text color="suggestion"> · Marked for update</Text>}
+        </Box>
+
+        {/* Installed components */}
+        <PluginComponentsDisplay plugin={selectedPlugin.plugin} marketplace={selectedPlugin.marketplace} />
+
+        {/* Plugin errors */}
+        {pluginErrorsSection}
+
+        {/* Menu */}
+        <Box marginTop={1} flexDirection="column">
+          {detailsMenuItems.map((item_9, index_0) => {
+          const isSelected = index_0 === detailsMenuIndex;
+          return <Box key={index_0}>
+                {isSelected && <Text>{figures.pointer} </Text>}
+                {!isSelected && <Text>{'  '}</Text>}
+                <Text bold={isSelected} color={item_9.label.includes('Uninstall') ? 'error' : item_9.label.includes('Update') ? 'suggestion' : undefined}>
+                  {item_9.label}
+                </Text>
+              </Box>;
+        })}
+        </Box>
+
+        {/* Processing state */}
+        {isProcessing && <Box marginTop={1}>
+            <Text>Processing…</Text>
+          </Box>}
+
+        {/* Error message */}
+        {processError && <Box marginTop={1}>
+            <Text color="error">{processError}</Text>
+          </Box>}
+
+        <Box marginTop={1}>
+          <Text dimColor italic>
+            <Byline>
+              <ConfigurableShortcutHint action="select:previous" context="Select" fallback="↑" description="navigate" />
+              <ConfigurableShortcutHint action="select:accept" context="Select" fallback="Enter" description="select" />
+              <ConfigurableShortcutHint action="confirm:no" context="Confirmation" fallback="Esc" description="back" />
+            </Byline>
+          </Text>
+        </Box>
+      </Box>;
+  }
+
+  // Failed plugin detail view
+  if (typeof viewState === 'object' && viewState.type === 'failed-plugin-details') {
+    const failedPlugin_0 = viewState.plugin;
+    const firstError = failedPlugin_0.errors[0];
+    const errorMessage_0 = firstError ? formatErrorMessage(firstError) : 'Failed to load';
+    return <Box flexDirection="column">
+        <Text>
+          <Text bold>{failedPlugin_0.name}</Text>
+          <Text dimColor> @ {failedPlugin_0.marketplace}</Text>
+          <Text dimColor> ({failedPlugin_0.scope})</Text>
+        </Text>
+        <Text color="error">{errorMessage_0}</Text>
+
+        {failedPlugin_0.scope === 'managed' ? <Box marginTop={1}>
+            <Text dimColor>
+              Managed by your organization — contact your admin
+            </Text>
+          </Box> : <Box marginTop={1}>
+            <Text color="suggestion">{figures.pointer} </Text>
+            <Text bold>Remove</Text>
+          </Box>}
+
+        {isProcessing && <Text>Processing…</Text>}
+        {processError && <Text color="error">{processError}</Text>}
+
+        <Box marginTop={1}>
+          <Text dimColor italic>
+            <Byline>
+              {failedPlugin_0.scope !== 'managed' && <ConfigurableShortcutHint action="select:accept" context="Select" fallback="Enter" description="remove" />}
+              <ConfigurableShortcutHint action="confirm:no" context="Confirmation" fallback="Esc" description="back" />
+            </Byline>
+          </Text>
+        </Box>
+      </Box>;
+  }
+
+  // MCP detail view
+  if (typeof viewState === 'object' && viewState.type === 'mcp-detail') {
+    const client_3 = viewState.client;
+    const serverToolsCount = filterToolsByServer(mcpTools, client_3.name).length;
+
+    // Common handlers for MCP menus
+    const handleMcpViewTools = () => {
+      setViewState({
+        type: 'mcp-tools',
+        client: client_3
+      });
+    };
+    const handleMcpCancel = () => {
+      setViewState('plugin-list');
+    };
+    const handleMcpComplete = (result_4?: string) => {
+      if (result_4) {
+        setResult(result_4);
+      }
+      setViewState('plugin-list');
+    };
+
+    // Transform MCPServerConnection to appropriate ServerInfo type
+    const scope_5 = client_3.config.scope;
+    const configType = client_3.config.type;
+    if (configType === 'stdio') {
+      const server: StdioServerInfo = {
+        name: client_3.name,
+        client: client_3,
+        scope: scope_5,
+        transport: 'stdio',
+        config: client_3.config as McpStdioServerConfig
+      };
+      return <MCPStdioServerMenu server={server} serverToolsCount={serverToolsCount} onViewTools={handleMcpViewTools} onCancel={handleMcpCancel} onComplete={handleMcpComplete} borderless />;
+    } else if (configType === 'sse') {
+      const server_0: SSEServerInfo = {
+        name: client_3.name,
+        client: client_3,
+        scope: scope_5,
+        transport: 'sse',
+        isAuthenticated: undefined,
+        config: client_3.config as McpSSEServerConfig
+      };
+      return <MCPRemoteServerMenu server={server_0} serverToolsCount={serverToolsCount} onViewTools={handleMcpViewTools} onCancel={handleMcpCancel} onComplete={handleMcpComplete} borderless />;
+    } else if (configType === 'http') {
+      const server_1: HTTPServerInfo = {
+        name: client_3.name,
+        client: client_3,
+        scope: scope_5,
+        transport: 'http',
+        isAuthenticated: undefined,
+        config: client_3.config as McpHTTPServerConfig
+      };
+      return <MCPRemoteServerMenu server={server_1} serverToolsCount={serverToolsCount} onViewTools={handleMcpViewTools} onCancel={handleMcpCancel} onComplete={handleMcpComplete} borderless />;
+    } else if (configType === 'claudeai-proxy') {
+      const server_2: ClaudeAIServerInfo = {
+        name: client_3.name,
+        client: client_3,
+        scope: scope_5,
+        transport: 'claudeai-proxy',
+        isAuthenticated: undefined,
+        config: client_3.config as McpClaudeAIProxyServerConfig
+      };
+      return <MCPRemoteServerMenu server={server_2} serverToolsCount={serverToolsCount} onViewTools={handleMcpViewTools} onCancel={handleMcpCancel} onComplete={handleMcpComplete} borderless />;
+    }
+
+    // Fallback - shouldn't happen but handle gracefully
+    setViewState('plugin-list');
+    return null;
+  }
+
+  // MCP tools view
+  if (typeof viewState === 'object' && viewState.type === 'mcp-tools') {
+    const client_4 = viewState.client;
+    const scope_6 = client_4.config.scope;
+    const configType_0 = client_4.config.type;
+
+    // Build ServerInfo for MCPToolListView
+    let server_3: StdioServerInfo | SSEServerInfo | HTTPServerInfo | ClaudeAIServerInfo;
+    if (configType_0 === 'stdio') {
+      server_3 = {
+        name: client_4.name,
+        client: client_4,
+        scope: scope_6,
+        transport: 'stdio',
+        config: client_4.config as McpStdioServerConfig
+      };
+    } else if (configType_0 === 'sse') {
+      server_3 = {
+        name: client_4.name,
+        client: client_4,
+        scope: scope_6,
+        transport: 'sse',
+        isAuthenticated: undefined,
+        config: client_4.config as McpSSEServerConfig
+      };
+    } else if (configType_0 === 'http') {
+      server_3 = {
+        name: client_4.name,
+        client: client_4,
+        scope: scope_6,
+        transport: 'http',
+        isAuthenticated: undefined,
+        config: client_4.config as McpHTTPServerConfig
+      };
+    } else {
+      server_3 = {
+        name: client_4.name,
+        client: client_4,
+        scope: scope_6,
+        transport: 'claudeai-proxy',
+        isAuthenticated: undefined,
+        config: client_4.config as McpClaudeAIProxyServerConfig
+      };
+    }
+    return <MCPToolListView server={server_3} onSelectTool={(tool: Tool) => {
+      setViewState({
+        type: 'mcp-tool-detail',
+        client: client_4,
+        tool
+      });
+    }} onBack={() => setViewState({
+      type: 'mcp-detail',
+      client: client_4
+    })} />;
+  }
+
+  // MCP tool detail view
+  if (typeof viewState === 'object' && viewState.type === 'mcp-tool-detail') {
+    const {
+      client: client_5,
+      tool: tool_0
+    } = viewState;
+    const scope_7 = client_5.config.scope;
+    const configType_1 = client_5.config.type;
+
+    // Build ServerInfo for MCPToolDetailView
+    let server_4: StdioServerInfo | SSEServerInfo | HTTPServerInfo | ClaudeAIServerInfo;
+    if (configType_1 === 'stdio') {
+      server_4 = {
+        name: client_5.name,
+        client: client_5,
+        scope: scope_7,
+        transport: 'stdio',
+        config: client_5.config as McpStdioServerConfig
+      };
+    } else if (configType_1 === 'sse') {
+      server_4 = {
+        name: client_5.name,
+        client: client_5,
+        scope: scope_7,
+        transport: 'sse',
+        isAuthenticated: undefined,
+        config: client_5.config as McpSSEServerConfig
+      };
+    } else if (configType_1 === 'http') {
+      server_4 = {
+        name: client_5.name,
+        client: client_5,
+        scope: scope_7,
+        transport: 'http',
+        isAuthenticated: undefined,
+        config: client_5.config as McpHTTPServerConfig
+      };
+    } else {
+      server_4 = {
+        name: client_5.name,
+        client: client_5,
+        scope: scope_7,
+        transport: 'claudeai-proxy',
+        isAuthenticated: undefined,
+        config: client_5.config as McpClaudeAIProxyServerConfig
+      };
+    }
+    return <MCPToolDetailView tool={tool_0} server={server_4} onBack={() => setViewState({
+      type: 'mcp-tools',
+      client: client_5
+    })} />;
+  }
+
+  // Plugin list view (main management interface)
+  const visibleItems = pagination.getVisibleItems(filteredItems);
+  return <Box flexDirection="column">
+      {/* Search box */}
+      <Box marginBottom={1}>
+        <SearchBox query={searchQuery} isFocused={isSearchMode} isTerminalFocused={isTerminalFocused} width={terminalWidth - 4} cursorOffset={searchCursorOffset} />
+      </Box>
+
+      {/* No search results */}
+      {filteredItems.length === 0 && searchQuery && <Box marginBottom={1}>
+          <Text dimColor>No items match &quot;{searchQuery}&quot;</Text>
+        </Box>}
+
+      {/* Scroll up indicator */}
+      {pagination.scrollPosition.canScrollUp && <Box>
+          <Text dimColor> {figures.arrowUp} more above</Text>
+        </Box>}
+
+      {/* Unified list of plugins and MCPs grouped by scope */}
+      {visibleItems.map((item_10, visibleIndex) => {
+      const actualIndex = pagination.toActualIndex(visibleIndex);
+      const isSelected_0 = actualIndex === selectedIndex && !isSearchMode;
+
+      // Check if we need to show a scope header
+      const prevItem = visibleIndex > 0 ? visibleItems[visibleIndex - 1] : null;
+      const showScopeHeader = !prevItem || prevItem.scope !== item_10.scope;
+
+      // Get scope label
+      const getScopeLabel = (scope_8: string): string => {
+        switch (scope_8) {
+          case 'flagged':
+            return 'Flagged';
+          case 'project':
+            return 'Project';
+          case 'local':
+            return 'Local';
+          case 'user':
+            return 'User';
+          case 'enterprise':
+            return 'Enterprise';
+          case 'managed':
+            return 'Managed';
+          case 'builtin':
+            return 'Built-in';
+          case 'dynamic':
+            return 'Built-in';
+          default:
+            return scope_8;
+        }
+      };
+      return <React.Fragment key={item_10.id}>
+            {showScopeHeader && <Box marginTop={visibleIndex > 0 ? 1 : 0} paddingLeft={2}>
+                <Text dimColor={item_10.scope !== 'flagged'} color={item_10.scope === 'flagged' ? 'warning' : undefined} bold={item_10.scope === 'flagged'}>
+                  {getScopeLabel(item_10.scope)}
+                </Text>
+              </Box>}
+            <UnifiedInstalledCell item={item_10} isSelected={isSelected_0} />
+          </React.Fragment>;
+    })}
+
+      {/* Scroll down indicator */}
+      {pagination.scrollPosition.canScrollDown && <Box>
+          <Text dimColor> {figures.arrowDown} more below</Text>
+        </Box>}
+
+      {/* Help text */}
+      <Box marginTop={1} marginLeft={1}>
+        <Text dimColor italic>
+          <Byline>
+            <Text>type to search</Text>
+            <ConfigurableShortcutHint action="plugin:toggle" context="Plugin" fallback="Space" description="toggle" />
+            <ConfigurableShortcutHint action="select:accept" context="Select" fallback="Enter" description="details" />
+            <ConfigurableShortcutHint action="confirm:no" context="Confirmation" fallback="Esc" description="back" />
+          </Byline>
+        </Text>
+      </Box>
+
+      {/* Reload disclaimer for plugin changes */}
+      {pendingToggles.size > 0 && <Box marginLeft={1}>
+          <Text dimColor italic>
+            Run /reload-plugins to apply changes
+          </Text>
+        </Box>}
+    </Box>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["figures","Dirent","fs","path","React","useCallback","useEffect","useMemo","useRef","useState","ConfigurableShortcutHint","Byline","MCPRemoteServerMenu","MCPStdioServerMenu","MCPToolDetailView","MCPToolListView","ClaudeAIServerInfo","HTTPServerInfo","SSEServerInfo","StdioServerInfo","SearchBox","useSearchInput","useTerminalSize","Box","Text","useInput","useTerminalFocus","useKeybinding","useKeybindings","getBuiltinPluginDefinition","useMcpToggleEnabled","MCPServerConnection","McpClaudeAIProxyServerConfig","McpHTTPServerConfig","McpSSEServerConfig","McpStdioServerConfig","filterToolsByServer","disablePluginOp","enablePluginOp","getPluginInstallationFromV2","isInstallableScope","isPluginEnabledAtProjectScope","uninstallPluginOp","updatePluginOp","useAppState","Tool","LoadedPlugin","PluginError","count","openBrowser","logForDebugging","errorMessage","toError","logError","clearAllCaches","loadInstalledPluginsV2","getMarketplace","isMcpbSource","loadMcpbFile","McpbNeedsConfigResult","UserConfigValues","getPluginDataDirSize","pluginDataDirPath","getFlaggedPlugins","markFlaggedPluginsSeen","removeFlaggedPlugin","PersistablePluginScope","parsePluginIdentifier","loadAllPlugins","loadPluginOptions","PluginOptionSchema","savePluginOptions","isPluginBlockedByPolicy","getPluginEditableScopes","getSettings_DEPRECATED","getSettingsForSource","updateSettingsForSource","jsonParse","plural","formatErrorMessage","getErrorGuidance","PluginOptionsDialog","PluginOptionsFlow","ViewState","ParentViewState","UnifiedInstalledCell","UnifiedInstalledItem","usePagination","Props","setViewState","state","setResult","result","onManageComplete","Promise","onSearchModeChange","isActive","targetPlugin","targetMarketplace","action","FlaggedPluginInfo","id","name","marketplace","reason","text","flaggedAt","FailedPluginInfo","errors","scope","type","schema","size","bytes","human","plugin","client","tool","MarketplaceInfo","installedPlugins","enabledCount","disabledCount","PluginState","pendingEnable","pendingUpdate","getBaseFileNames","dirPath","entries","readdir","withFileTypes","filter","entry","isFile","endsWith","map","baseName","basename","error","errorMsg","level","getSkillDirNames","skillNames","isDirectory","isSymbolicLink","skillFilePath","join","st","stat","push","PluginComponentsDisplay","ReactNode","components","setComponents","commands","Record","agents","skills","hooks","mcpServers","loading","setLoading","setError","loadComponents","builtinDef","s","hookEvents","Object","keys","mcpServerNames","length","marketplaceData","pluginEntry","plugins","find","p","commandPathList","commandsPath","commandsPaths","commandList","commandPath","baseNames","agentPathList","agentsPath","agentsPaths","agentList","agentPath","skillPathList","skillsPath","skillsPaths","skillList","skillPath","skillDirNames","hooksList","hooksConfig","mcpServersList","err","Error","message","hasComponents","Array","isArray","String","checkIfLocalPlugin","pluginName","marketplaceName","source","filterManagedDisabledPlugins","split","ManagePlugins","setParentViewState","mcpClients","mcp","clients","mcpTools","tools","pluginErrors","flaggedPlugins","isSearchMode","setIsSearchModeRaw","setIsSearchMode","active","isTerminalFocused","columns","terminalWidth","viewState","query","searchQuery","setQuery","setSearchQuery","cursorOffset","searchCursorOffset","onExit","selectedPlugin","setSelectedPlugin","marketplaces","setMarketplaces","pluginStates","setPluginStates","pendingToggles","setPendingToggles","Map","hasAutoNavigated","pendingAutoActionRef","undefined","toggleMcpServer","handleBack","setProcessError","setConfigNeeded","context","getMcpStatus","unifiedItems","mergedSettings","pluginMcpMap","displayName","startsWith","parts","serverName","slice","existing","get","set","PluginWithChildren","item","originalScope","childMcps","pluginsWithChildren","pluginId","isEnabled","enabledPlugins","e","isBuiltin","description","manifest","errorCount","pendingToggle","matchedPluginIds","Set","matchedPluginNames","orphanErrorsBySource","has","pluginScopes","failedPluginItems","parsed","rawScope","standaloneMcps","config","status","scopeOrder","flagged","project","local","user","enterprise","managed","dynamic","builtin","unified","itemsByScope","displayScope","indented","failedPlugin","sortedScopes","sort","a","b","items","pluginGroups","standaloneMcpsInScope","i","group","nextItem","localeCompare","flaggedIds","filteredItems","lowerQuery","toLowerCase","includes","selectedIndex","setSelectedIndex","pagination","totalItems","maxVisible","detailsMenuIndex","setDetailsMenuIndex","isProcessing","setIsProcessing","processError","configNeeded","_isLoadingConfig","setIsLoadingConfig","selectedPluginHasMcpb","setSelectedPluginHasMcpb","detectMcpb","mcpServersSpec","hasMcpb","some","marketplaceDir","marketplaceJsonPath","content","readFile","spec","loadInstalledPlugins","enabled","disabled","allPlugins","pluginsByMarketplace","marketplaceInfos","allStates","current","targetName","targetMktFromId","effectiveTargetMarketplace","marketplacesToSearch","m","pluginState","failedItem","handleSingleOperation","operation","pluginScope","reverseDependents","enableResult","success","disableResult","installs","isLastScope","dataSize","alreadyUpToDate","newVersion","pluginIdNow","settingsAfter","enabledAfter","operationName","depWarn","handleSingleOperationRef","pending","handleToggle","currentPending","newPending","delete","handleAccept","select:previous","handleSelectionChange","select:next","handleFlaggedDismiss","detailsMenuItems","menuItems","label","localError","newStates","index","findIndex","mcpbPath","userConfig","homepage","repository","select:accept","editableSources","const","settings","confirm:yes","confirm:no","input","key","doUninstall","deleteDataDir","suffix","tick","escape","keyIsNotCtrlOrMeta","ctrl","meta","test","finish","msg","outcome","detail","values","handleSave","handleCancel","configSchema","existingConfig","fp","Date","toLocaleDateString","pointer","filteredPluginErrors","pluginErrorsSection","guidance","arrowRight","version","author","isSelected","firstError","serverToolsCount","handleMcpViewTools","handleMcpCancel","handleMcpComplete","configType","server","transport","isAuthenticated","visibleItems","getVisibleItems","scrollPosition","canScrollUp","arrowUp","visibleIndex","actualIndex","toActualIndex","prevItem","showScopeHeader","getScopeLabel","canScrollDown","arrowDown"],"sources":["ManagePlugins.tsx"],"sourcesContent":["import figures from 'figures'\nimport type { Dirent } from 'fs'\nimport * as fs from 'fs/promises'\nimport * as path from 'path'\nimport * as React from 'react'\nimport { useCallback, useEffect, useMemo, useRef, useState } from 'react'\nimport { ConfigurableShortcutHint } from '../../components/ConfigurableShortcutHint.js'\nimport { Byline } from '../../components/design-system/Byline.js'\nimport { MCPRemoteServerMenu } from '../../components/mcp/MCPRemoteServerMenu.js'\nimport { MCPStdioServerMenu } from '../../components/mcp/MCPStdioServerMenu.js'\nimport { MCPToolDetailView } from '../../components/mcp/MCPToolDetailView.js'\nimport { MCPToolListView } from '../../components/mcp/MCPToolListView.js'\nimport type {\n  ClaudeAIServerInfo,\n  HTTPServerInfo,\n  SSEServerInfo,\n  StdioServerInfo,\n} from '../../components/mcp/types.js'\nimport { SearchBox } from '../../components/SearchBox.js'\nimport { useSearchInput } from '../../hooks/useSearchInput.js'\nimport { useTerminalSize } from '../../hooks/useTerminalSize.js'\n// eslint-disable-next-line custom-rules/prefer-use-keybindings -- useInput needed for raw search mode text input\nimport { Box, Text, useInput, useTerminalFocus } from '../../ink.js'\nimport {\n  useKeybinding,\n  useKeybindings,\n} from '../../keybindings/useKeybinding.js'\nimport { getBuiltinPluginDefinition } from '../../plugins/builtinPlugins.js'\nimport { useMcpToggleEnabled } from '../../services/mcp/MCPConnectionManager.js'\nimport type {\n  MCPServerConnection,\n  McpClaudeAIProxyServerConfig,\n  McpHTTPServerConfig,\n  McpSSEServerConfig,\n  McpStdioServerConfig,\n} from '../../services/mcp/types.js'\nimport { filterToolsByServer } from '../../services/mcp/utils.js'\nimport {\n  disablePluginOp,\n  enablePluginOp,\n  getPluginInstallationFromV2,\n  isInstallableScope,\n  isPluginEnabledAtProjectScope,\n  uninstallPluginOp,\n  updatePluginOp,\n} from '../../services/plugins/pluginOperations.js'\nimport { useAppState } from '../../state/AppState.js'\nimport type { Tool } from '../../Tool.js'\nimport type { LoadedPlugin, PluginError } from '../../types/plugin.js'\nimport { count } from '../../utils/array.js'\nimport { openBrowser } from '../../utils/browser.js'\nimport { logForDebugging } from '../../utils/debug.js'\nimport { errorMessage, toError } from '../../utils/errors.js'\nimport { logError } from '../../utils/log.js'\nimport { clearAllCaches } from '../../utils/plugins/cacheUtils.js'\nimport { loadInstalledPluginsV2 } from '../../utils/plugins/installedPluginsManager.js'\nimport { getMarketplace } from '../../utils/plugins/marketplaceManager.js'\nimport {\n  isMcpbSource,\n  loadMcpbFile,\n  type McpbNeedsConfigResult,\n  type UserConfigValues,\n} from '../../utils/plugins/mcpbHandler.js'\nimport {\n  getPluginDataDirSize,\n  pluginDataDirPath,\n} from '../../utils/plugins/pluginDirectories.js'\nimport {\n  getFlaggedPlugins,\n  markFlaggedPluginsSeen,\n  removeFlaggedPlugin,\n} from '../../utils/plugins/pluginFlagging.js'\nimport {\n  type PersistablePluginScope,\n  parsePluginIdentifier,\n} from '../../utils/plugins/pluginIdentifier.js'\nimport { loadAllPlugins } from '../../utils/plugins/pluginLoader.js'\nimport {\n  loadPluginOptions,\n  type PluginOptionSchema,\n  savePluginOptions,\n} from '../../utils/plugins/pluginOptionsStorage.js'\nimport { isPluginBlockedByPolicy } from '../../utils/plugins/pluginPolicy.js'\nimport { getPluginEditableScopes } from '../../utils/plugins/pluginStartupCheck.js'\nimport {\n  getSettings_DEPRECATED,\n  getSettingsForSource,\n  updateSettingsForSource,\n} from '../../utils/settings/settings.js'\nimport { jsonParse } from '../../utils/slowOperations.js'\nimport { plural } from '../../utils/stringUtils.js'\nimport { formatErrorMessage, getErrorGuidance } from './PluginErrors.js'\nimport { PluginOptionsDialog } from './PluginOptionsDialog.js'\nimport { PluginOptionsFlow } from './PluginOptionsFlow.js'\nimport type { ViewState as ParentViewState } from './types.js'\nimport { UnifiedInstalledCell } from './UnifiedInstalledCell.js'\nimport type { UnifiedInstalledItem } from './unifiedTypes.js'\nimport { usePagination } from './usePagination.js'\n\ntype Props = {\n  setViewState: (state: ParentViewState) => void\n  setResult: (result: string | null) => void\n  onManageComplete?: () => void | Promise<void>\n  onSearchModeChange?: (isActive: boolean) => void\n  targetPlugin?: string\n  targetMarketplace?: string\n  action?: 'enable' | 'disable' | 'uninstall'\n}\n\ntype FlaggedPluginInfo = {\n  id: string\n  name: string\n  marketplace: string\n  reason: string\n  text: string\n  flaggedAt: string\n}\n\ntype FailedPluginInfo = {\n  id: string\n  name: string\n  marketplace: string\n  errors: PluginError[]\n  scope: PersistablePluginScope\n}\n\ntype ViewState =\n  | 'plugin-list'\n  | 'plugin-details'\n  | 'configuring'\n  | { type: 'plugin-options' }\n  | { type: 'configuring-options'; schema: PluginOptionSchema }\n  | 'confirm-project-uninstall'\n  | { type: 'confirm-data-cleanup'; size: { bytes: number; human: string } }\n  | { type: 'flagged-detail'; plugin: FlaggedPluginInfo }\n  | { type: 'failed-plugin-details'; plugin: FailedPluginInfo }\n  | { type: 'mcp-detail'; client: MCPServerConnection }\n  | { type: 'mcp-tools'; client: MCPServerConnection }\n  | { type: 'mcp-tool-detail'; client: MCPServerConnection; tool: Tool }\n\ntype MarketplaceInfo = {\n  name: string\n  installedPlugins: LoadedPlugin[]\n  enabledCount?: number\n  disabledCount?: number\n}\n\ntype PluginState = {\n  plugin: LoadedPlugin\n  marketplace: string\n  scope?: 'user' | 'project' | 'local' | 'managed' | 'builtin'\n  pendingEnable?: boolean // Toggle enable/disable\n  pendingUpdate?: boolean // Marked for update\n}\n\n/**\n * Get list of base file names (without .md extension) from a directory\n * @param dirPath The directory path to list files from\n * @returns Array of base file names without .md extension\n * @example\n * // Given directory contains: agent-sdk-verifier-py.md, agent-sdk-verifier-ts.md, README.txt\n * await getBaseFileNames('/path/to/agents')\n * // Returns: ['agent-sdk-verifier-py', 'agent-sdk-verifier-ts']\n */\nasync function getBaseFileNames(dirPath: string): Promise<string[]> {\n  try {\n    const entries = await fs.readdir(dirPath, { withFileTypes: true })\n    return entries\n      .filter((entry: Dirent) => entry.isFile() && entry.name.endsWith('.md'))\n      .map((entry: Dirent) => {\n        // Remove .md extension specifically\n        const baseName = path.basename(entry.name, '.md')\n        return baseName\n      })\n  } catch (error) {\n    const errorMsg = errorMessage(error)\n    logForDebugging(\n      `Failed to read plugin components from ${dirPath}: ${errorMsg}`,\n      { level: 'error' },\n    )\n    logError(toError(error))\n    // Return empty array to allow graceful degradation - plugin details can still be shown\n    return []\n  }\n}\n\n/**\n * Get list of skill directory names from a skills directory\n * Skills are directories containing a SKILL.md file\n * @param dirPath The skills directory path to scan\n * @returns Array of skill directory names that contain SKILL.md\n * @example\n * // Given directory contains: my-skill/SKILL.md, another-skill/SKILL.md, README.txt\n * await getSkillDirNames('/path/to/skills')\n * // Returns: ['my-skill', 'another-skill']\n */\nasync function getSkillDirNames(dirPath: string): Promise<string[]> {\n  try {\n    const entries = await fs.readdir(dirPath, { withFileTypes: true })\n    const skillNames: string[] = []\n\n    for (const entry of entries) {\n      // Check if it's a directory or symlink (symlinks may point to skill directories)\n      if (entry.isDirectory() || entry.isSymbolicLink()) {\n        // Check if this directory contains a SKILL.md file\n        const skillFilePath = path.join(dirPath, entry.name, 'SKILL.md')\n        try {\n          const st = await fs.stat(skillFilePath)\n          if (st.isFile()) {\n            skillNames.push(entry.name)\n          }\n        } catch {\n          // No SKILL.md file in this directory, skip it\n        }\n      }\n    }\n\n    return skillNames\n  } catch (error) {\n    const errorMsg = errorMessage(error)\n    logForDebugging(\n      `Failed to read skill directories from ${dirPath}: ${errorMsg}`,\n      { level: 'error' },\n    )\n    logError(toError(error))\n    // Return empty array to allow graceful degradation - plugin details can still be shown\n    return []\n  }\n}\n\n// Component to display installed plugin components\nfunction PluginComponentsDisplay({\n  plugin,\n  marketplace,\n}: {\n  plugin: LoadedPlugin\n  marketplace: string\n}): React.ReactNode {\n  const [components, setComponents] = useState<{\n    commands?: string | string[] | Record<string, unknown> | null\n    agents?: string | string[] | Record<string, unknown> | null\n    skills?: string | string[] | Record<string, unknown> | null\n    hooks?: unknown\n    mcpServers?: unknown\n  } | null>(null)\n  const [loading, setLoading] = useState(true)\n  const [error, setError] = useState<string | null>(null)\n\n  useEffect(() => {\n    async function loadComponents() {\n      try {\n        // Built-in plugins don't have a marketplace entry — read from the\n        // registered definition directly.\n        if (marketplace === 'builtin') {\n          const builtinDef = getBuiltinPluginDefinition(plugin.name)\n          if (builtinDef) {\n            const skillNames = builtinDef.skills?.map(s => s.name) ?? []\n            const hookEvents = builtinDef.hooks\n              ? Object.keys(builtinDef.hooks)\n              : []\n            const mcpServerNames = builtinDef.mcpServers\n              ? Object.keys(builtinDef.mcpServers)\n              : []\n            setComponents({\n              commands: null,\n              agents: null,\n              skills: skillNames.length > 0 ? skillNames : null,\n              hooks: hookEvents.length > 0 ? hookEvents : null,\n              mcpServers: mcpServerNames.length > 0 ? mcpServerNames : null,\n            })\n          } else {\n            setError(`Built-in plugin ${plugin.name} not found`)\n          }\n          setLoading(false)\n          return\n        }\n\n        const marketplaceData = await getMarketplace(marketplace)\n        // Find the plugin entry in the array\n        const pluginEntry = marketplaceData.plugins.find(\n          p => p.name === plugin.name,\n        )\n        if (pluginEntry) {\n          // Combine commands from both sources\n          const commandPathList = []\n          if (plugin.commandsPath) {\n            commandPathList.push(plugin.commandsPath)\n          }\n          if (plugin.commandsPaths) {\n            commandPathList.push(...plugin.commandsPaths)\n          }\n\n          // Get base file names from all command paths\n          const commandList: string[] = []\n          for (const commandPath of commandPathList) {\n            if (typeof commandPath === 'string') {\n              // commandPath is already a full path\n              const baseNames = await getBaseFileNames(commandPath)\n              commandList.push(...baseNames)\n            }\n          }\n\n          // Combine agents from both sources\n          const agentPathList = []\n          if (plugin.agentsPath) {\n            agentPathList.push(plugin.agentsPath)\n          }\n          if (plugin.agentsPaths) {\n            agentPathList.push(...plugin.agentsPaths)\n          }\n\n          // Get base file names from all agent paths\n          const agentList: string[] = []\n          for (const agentPath of agentPathList) {\n            if (typeof agentPath === 'string') {\n              // agentPath is already a full path\n              const baseNames = await getBaseFileNames(agentPath)\n              agentList.push(...baseNames)\n            }\n          }\n\n          // Combine skills from both sources\n          const skillPathList = []\n          if (plugin.skillsPath) {\n            skillPathList.push(plugin.skillsPath)\n          }\n          if (plugin.skillsPaths) {\n            skillPathList.push(...plugin.skillsPaths)\n          }\n\n          // Get skill directory names from all skill paths\n          // Skills are directories containing SKILL.md files\n          const skillList: string[] = []\n          for (const skillPath of skillPathList) {\n            if (typeof skillPath === 'string') {\n              // skillPath is already a full path to a skills directory\n              const skillDirNames = await getSkillDirNames(skillPath)\n              skillList.push(...skillDirNames)\n            }\n          }\n\n          // Combine hooks from both sources\n          const hooksList = []\n          if (plugin.hooksConfig) {\n            hooksList.push(Object.keys(plugin.hooksConfig))\n          }\n          if (pluginEntry.hooks) {\n            hooksList.push(pluginEntry.hooks)\n          }\n\n          // Combine MCP servers from both sources\n          const mcpServersList = []\n          if (plugin.mcpServers) {\n            mcpServersList.push(Object.keys(plugin.mcpServers))\n          }\n          if (pluginEntry.mcpServers) {\n            mcpServersList.push(pluginEntry.mcpServers)\n          }\n\n          setComponents({\n            commands: commandList.length > 0 ? commandList : null,\n            agents: agentList.length > 0 ? agentList : null,\n            skills: skillList.length > 0 ? skillList : null,\n            hooks: hooksList.length > 0 ? hooksList : null,\n            mcpServers: mcpServersList.length > 0 ? mcpServersList : null,\n          })\n        } else {\n          setError(`Plugin ${plugin.name} not found in marketplace`)\n        }\n      } catch (err) {\n        setError(\n          err instanceof Error ? err.message : 'Failed to load components',\n        )\n      } finally {\n        setLoading(false)\n      }\n    }\n    void loadComponents()\n  }, [\n    plugin.name,\n    plugin.commandsPath,\n    plugin.commandsPaths,\n    plugin.agentsPath,\n    plugin.agentsPaths,\n    plugin.skillsPath,\n    plugin.skillsPaths,\n    plugin.hooksConfig,\n    plugin.mcpServers,\n    marketplace,\n  ])\n\n  if (loading) {\n    return null // Don't show loading state for cleaner UI\n  }\n\n  if (error) {\n    return (\n      <Box flexDirection=\"column\" marginBottom={1}>\n        <Text bold>Components:</Text>\n        <Text dimColor>Error: {error}</Text>\n      </Box>\n    )\n  }\n\n  if (!components) {\n    return null // No components info available\n  }\n\n  const hasComponents =\n    components.commands ||\n    components.agents ||\n    components.skills ||\n    components.hooks ||\n    components.mcpServers\n\n  if (!hasComponents) {\n    return null // No components defined\n  }\n\n  return (\n    <Box flexDirection=\"column\" marginBottom={1}>\n      <Text bold>Installed components:</Text>\n      {components.commands ? (\n        <Text dimColor>\n          • Commands:{' '}\n          {typeof components.commands === 'string'\n            ? components.commands\n            : Array.isArray(components.commands)\n              ? components.commands.join(', ')\n              : Object.keys(components.commands).join(', ')}\n        </Text>\n      ) : null}\n      {components.agents ? (\n        <Text dimColor>\n          • Agents:{' '}\n          {typeof components.agents === 'string'\n            ? components.agents\n            : Array.isArray(components.agents)\n              ? components.agents.join(', ')\n              : Object.keys(components.agents).join(', ')}\n        </Text>\n      ) : null}\n      {components.skills ? (\n        <Text dimColor>\n          • Skills:{' '}\n          {typeof components.skills === 'string'\n            ? components.skills\n            : Array.isArray(components.skills)\n              ? components.skills.join(', ')\n              : Object.keys(components.skills).join(', ')}\n        </Text>\n      ) : null}\n      {components.hooks ? (\n        <Text dimColor>\n          • Hooks:{' '}\n          {typeof components.hooks === 'string'\n            ? components.hooks\n            : Array.isArray(components.hooks)\n              ? components.hooks.map(String).join(', ')\n              : typeof components.hooks === 'object' &&\n                  components.hooks !== null\n                ? Object.keys(components.hooks).join(', ')\n                : String(components.hooks)}\n        </Text>\n      ) : null}\n      {components.mcpServers ? (\n        <Text dimColor>\n          • MCP Servers:{' '}\n          {typeof components.mcpServers === 'string'\n            ? components.mcpServers\n            : Array.isArray(components.mcpServers)\n              ? components.mcpServers.map(String).join(', ')\n              : typeof components.mcpServers === 'object' &&\n                  components.mcpServers !== null\n                ? Object.keys(components.mcpServers).join(', ')\n                : String(components.mcpServers)}\n        </Text>\n      ) : null}\n    </Box>\n  )\n}\n\n/**\n * Check if a plugin is from a local source and cannot be remotely updated\n * @returns Error message if local, null if remote/updatable\n */\nasync function checkIfLocalPlugin(\n  pluginName: string,\n  marketplaceName: string,\n): Promise<string | null> {\n  const marketplace = await getMarketplace(marketplaceName)\n  const entry = marketplace?.plugins.find(p => p.name === pluginName)\n\n  if (entry && typeof entry.source === 'string') {\n    return `Local plugins cannot be updated remotely. To update, modify the source at: ${entry.source}`\n  }\n\n  return null\n}\n\n/**\n * Filter out plugins that are force-disabled by org policy (policySettings).\n * These are blocked by the organization and cannot be re-enabled by the user.\n * Checks policySettings directly rather than installation scope, since managed\n * settings don't create installation records with scope 'managed'.\n */\nexport function filterManagedDisabledPlugins(\n  plugins: LoadedPlugin[],\n): LoadedPlugin[] {\n  return plugins.filter(plugin => {\n    const marketplace = plugin.source.split('@')[1] || 'local'\n    return !isPluginBlockedByPolicy(`${plugin.name}@${marketplace}`)\n  })\n}\n\nexport function ManagePlugins({\n  setViewState: setParentViewState,\n  setResult,\n  onManageComplete,\n  onSearchModeChange,\n  targetPlugin,\n  targetMarketplace,\n  action,\n}: Props): React.ReactNode {\n  // App state for MCP access\n  const mcpClients = useAppState(s => s.mcp.clients)\n  const mcpTools = useAppState(s => s.mcp.tools)\n  const pluginErrors = useAppState(s => s.plugins.errors)\n  const flaggedPlugins = getFlaggedPlugins()\n\n  // Search state\n  const [isSearchMode, setIsSearchModeRaw] = useState(false)\n  const setIsSearchMode = useCallback(\n    (active: boolean) => {\n      setIsSearchModeRaw(active)\n      onSearchModeChange?.(active)\n    },\n    [onSearchModeChange],\n  )\n  const isTerminalFocused = useTerminalFocus()\n  const { columns: terminalWidth } = useTerminalSize()\n\n  // View state\n  const [viewState, setViewState] = useState<ViewState>('plugin-list')\n\n  const {\n    query: searchQuery,\n    setQuery: setSearchQuery,\n    cursorOffset: searchCursorOffset,\n  } = useSearchInput({\n    isActive: viewState === 'plugin-list' && isSearchMode,\n    onExit: () => {\n      setIsSearchMode(false)\n    },\n  })\n  const [selectedPlugin, setSelectedPlugin] = useState<PluginState | null>(null)\n\n  // Data state\n  const [marketplaces, setMarketplaces] = useState<MarketplaceInfo[]>([])\n  const [pluginStates, setPluginStates] = useState<PluginState[]>([])\n  const [loading, setLoading] = useState(true)\n  const [pendingToggles, setPendingToggles] = useState<\n    Map<string, 'will-enable' | 'will-disable'>\n  >(new Map())\n\n  // Guard to prevent auto-navigation from re-triggering after the user\n  // navigates away (targetPlugin is never cleared by the parent).\n  const hasAutoNavigated = useRef(false)\n  // Auto-action (enable/disable/uninstall) to fire after auto-navigation lands.\n  // Ref, not state: it's consumed by a one-shot effect that already re-runs on\n  // viewState/selectedPlugin, so a render-triggering state var would be redundant.\n  const pendingAutoActionRef = useRef<\n    'enable' | 'disable' | 'uninstall' | undefined\n  >(undefined)\n\n  // MCP toggle hook\n  const toggleMcpServer = useMcpToggleEnabled()\n\n  // Handle escape to go back - viewState-dependent navigation\n  const handleBack = React.useCallback(() => {\n    if (viewState === 'plugin-details') {\n      setViewState('plugin-list')\n      setSelectedPlugin(null)\n      setProcessError(null)\n    } else if (\n      typeof viewState === 'object' &&\n      viewState.type === 'failed-plugin-details'\n    ) {\n      setViewState('plugin-list')\n      setProcessError(null)\n    } else if (viewState === 'configuring') {\n      setViewState('plugin-details')\n      setConfigNeeded(null)\n    } else if (\n      typeof viewState === 'object' &&\n      (viewState.type === 'plugin-options' ||\n        viewState.type === 'configuring-options')\n    ) {\n      // Cancel mid-sequence — plugin is already enabled, just bail to list.\n      // User can configure later via the Configure options menu if they want.\n      setViewState('plugin-list')\n      setSelectedPlugin(null)\n      setResult(\n        'Plugin enabled. Configuration skipped — run /reload-plugins to apply.',\n      )\n      if (onManageComplete) {\n        void onManageComplete()\n      }\n    } else if (\n      typeof viewState === 'object' &&\n      viewState.type === 'flagged-detail'\n    ) {\n      setViewState('plugin-list')\n      setProcessError(null)\n    } else if (\n      typeof viewState === 'object' &&\n      viewState.type === 'mcp-detail'\n    ) {\n      setViewState('plugin-list')\n      setProcessError(null)\n    } else if (\n      typeof viewState === 'object' &&\n      viewState.type === 'mcp-tools'\n    ) {\n      setViewState({ type: 'mcp-detail', client: viewState.client })\n    } else if (\n      typeof viewState === 'object' &&\n      viewState.type === 'mcp-tool-detail'\n    ) {\n      setViewState({ type: 'mcp-tools', client: viewState.client })\n    } else {\n      if (pendingToggles.size > 0) {\n        setResult('Run /reload-plugins to apply plugin changes.')\n        return\n      }\n      setParentViewState({ type: 'menu' })\n    }\n  }, [viewState, setParentViewState, pendingToggles, setResult])\n\n  // Escape when not in search mode - go back.\n  // Excludes confirm-project-uninstall (has its own confirm:no handler in\n  // Confirmation context — letting this fire would create competing handlers)\n  // and confirm-data-cleanup (uses raw useInput where n and escape are\n  // DIFFERENT actions: keep-data vs cancel).\n  useKeybinding('confirm:no', handleBack, {\n    context: 'Confirmation',\n    isActive:\n      (viewState !== 'plugin-list' || !isSearchMode) &&\n      viewState !== 'confirm-project-uninstall' &&\n      !(\n        typeof viewState === 'object' &&\n        viewState.type === 'confirm-data-cleanup'\n      ),\n  })\n\n  // Helper to get MCP status\n  const getMcpStatus = (\n    client: MCPServerConnection,\n  ): 'connected' | 'disabled' | 'pending' | 'needs-auth' | 'failed' => {\n    if (client.type === 'connected') return 'connected'\n    if (client.type === 'disabled') return 'disabled'\n    if (client.type === 'pending') return 'pending'\n    if (client.type === 'needs-auth') return 'needs-auth'\n    return 'failed'\n  }\n\n  // Derive unified items from plugins and MCP servers\n  const unifiedItems = useMemo(() => {\n    const mergedSettings = getSettings_DEPRECATED()\n\n    // Build map of plugin name -> child MCPs\n    // Plugin MCPs have names like \"plugin:pluginName:serverName\"\n    const pluginMcpMap = new Map<\n      string,\n      Array<{ displayName: string; client: MCPServerConnection }>\n    >()\n    for (const client of mcpClients) {\n      if (client.name.startsWith('plugin:')) {\n        const parts = client.name.split(':')\n        if (parts.length >= 3) {\n          const pluginName = parts[1]!\n          const serverName = parts.slice(2).join(':')\n          const existing = pluginMcpMap.get(pluginName) || []\n          existing.push({ displayName: serverName, client })\n          pluginMcpMap.set(pluginName, existing)\n        }\n      }\n    }\n\n    // Build plugin items (unsorted for now)\n    type PluginWithChildren = {\n      item: UnifiedInstalledItem & { type: 'plugin' }\n      originalScope: 'user' | 'project' | 'local' | 'managed' | 'builtin'\n      childMcps: Array<{ displayName: string; client: MCPServerConnection }>\n    }\n    const pluginsWithChildren: PluginWithChildren[] = []\n\n    for (const state of pluginStates) {\n      const pluginId = `${state.plugin.name}@${state.marketplace}`\n      const isEnabled = mergedSettings?.enabledPlugins?.[pluginId] !== false\n      const errors = pluginErrors.filter(\n        e =>\n          ('plugin' in e && e.plugin === state.plugin.name) ||\n          e.source === pluginId ||\n          e.source.startsWith(`${state.plugin.name}@`),\n      )\n\n      // Built-in plugins use 'builtin' scope; others look up from V2 data.\n      const originalScope = state.plugin.isBuiltin\n        ? 'builtin'\n        : state.scope || 'user'\n\n      pluginsWithChildren.push({\n        item: {\n          type: 'plugin',\n          id: pluginId,\n          name: state.plugin.name,\n          description: state.plugin.manifest.description,\n          marketplace: state.marketplace,\n          scope: originalScope,\n          isEnabled,\n          errorCount: errors.length,\n          errors,\n          plugin: state.plugin,\n          pendingEnable: state.pendingEnable,\n          pendingUpdate: state.pendingUpdate,\n          pendingToggle: pendingToggles.get(pluginId),\n        },\n        originalScope,\n        childMcps: pluginMcpMap.get(state.plugin.name) || [],\n      })\n    }\n\n    // Find orphan errors (errors for plugins that failed to load entirely)\n    const matchedPluginIds = new Set(\n      pluginsWithChildren.map(({ item }) => item.id),\n    )\n    const matchedPluginNames = new Set(\n      pluginsWithChildren.map(({ item }) => item.name),\n    )\n    const orphanErrorsBySource = new Map<string, typeof pluginErrors>()\n    for (const error of pluginErrors) {\n      if (\n        matchedPluginIds.has(error.source) ||\n        ('plugin' in error &&\n          typeof error.plugin === 'string' &&\n          matchedPluginNames.has(error.plugin))\n      ) {\n        continue\n      }\n      const existing = orphanErrorsBySource.get(error.source) || []\n      existing.push(error)\n      orphanErrorsBySource.set(error.source, existing)\n    }\n    const pluginScopes = getPluginEditableScopes()\n    const failedPluginItems: UnifiedInstalledItem[] = []\n    for (const [pluginId, errors] of orphanErrorsBySource) {\n      // Skip plugins that are already shown in the flagged section\n      if (pluginId in flaggedPlugins) continue\n      const parsed = parsePluginIdentifier(pluginId)\n      const pluginName = parsed.name || pluginId\n      const marketplace = parsed.marketplace || 'unknown'\n      const rawScope = pluginScopes.get(pluginId)\n      // 'flag' is session-only (from --plugin-dir / flagSettings) and undefined\n      // means the plugin isn't in any settings source. Default both to 'user'\n      // since UnifiedInstalledItem doesn't have a 'flag' scope variant.\n      const scope =\n        rawScope === 'flag' || rawScope === undefined ? 'user' : rawScope\n      failedPluginItems.push({\n        type: 'failed-plugin',\n        id: pluginId,\n        name: pluginName,\n        marketplace,\n        scope,\n        errorCount: errors.length,\n        errors,\n      })\n    }\n\n    // Build standalone MCP items\n    const standaloneMcps: UnifiedInstalledItem[] = []\n    for (const client of mcpClients) {\n      if (client.name === 'ide') continue\n      if (client.name.startsWith('plugin:')) continue\n\n      standaloneMcps.push({\n        type: 'mcp',\n        id: `mcp:${client.name}`,\n        name: client.name,\n        description: undefined,\n        scope: client.config.scope,\n        status: getMcpStatus(client),\n        client,\n      })\n    }\n\n    // Define scope order for display\n    const scopeOrder: Record<string, number> = {\n      flagged: -1,\n      project: 0,\n      local: 1,\n      user: 2,\n      enterprise: 3,\n      managed: 4,\n      dynamic: 5,\n      builtin: 6,\n    }\n\n    // Build final list by merging plugins (with their child MCPs) and standalone MCPs\n    // Group by scope to avoid duplicate scope headers\n    const unified: UnifiedInstalledItem[] = []\n\n    // Create a map of scope -> items for proper merging\n    const itemsByScope = new Map<string, UnifiedInstalledItem[]>()\n\n    // Add plugins with their child MCPs\n    for (const { item, originalScope, childMcps } of pluginsWithChildren) {\n      const scope = item.scope\n      if (!itemsByScope.has(scope)) {\n        itemsByScope.set(scope, [])\n      }\n      itemsByScope.get(scope)!.push(item)\n      // Add child MCPs right after the plugin, indented (use original scope, not 'flagged').\n      // Built-in plugins map to 'user' for display since MCP ConfigScope doesn't include 'builtin'.\n      for (const { displayName, client } of childMcps) {\n        const displayScope =\n          originalScope === 'builtin' ? 'user' : originalScope\n        if (!itemsByScope.has(displayScope)) {\n          itemsByScope.set(displayScope, [])\n        }\n        itemsByScope.get(displayScope)!.push({\n          type: 'mcp',\n          id: `mcp:${client.name}`,\n          name: displayName,\n          description: undefined,\n          scope: displayScope,\n          status: getMcpStatus(client),\n          client,\n          indented: true,\n        })\n      }\n    }\n\n    // Add standalone MCPs to their respective scope groups\n    for (const mcp of standaloneMcps) {\n      const scope = mcp.scope\n      if (!itemsByScope.has(scope)) {\n        itemsByScope.set(scope, [])\n      }\n      itemsByScope.get(scope)!.push(mcp)\n    }\n\n    // Add failed plugins to their respective scope groups\n    for (const failedPlugin of failedPluginItems) {\n      const scope = failedPlugin.scope\n      if (!itemsByScope.has(scope)) {\n        itemsByScope.set(scope, [])\n      }\n      itemsByScope.get(scope)!.push(failedPlugin)\n    }\n\n    // Add flagged (delisted) plugins from user settings.\n    // Reason/text are looked up from the cached security messages file.\n    for (const [pluginId, entry] of Object.entries(flaggedPlugins)) {\n      const parsed = parsePluginIdentifier(pluginId)\n      const pluginName = parsed.name || pluginId\n      const marketplace = parsed.marketplace || 'unknown'\n      if (!itemsByScope.has('flagged')) {\n        itemsByScope.set('flagged', [])\n      }\n      itemsByScope.get('flagged')!.push({\n        type: 'flagged-plugin',\n        id: pluginId,\n        name: pluginName,\n        marketplace,\n        scope: 'flagged',\n        reason: 'delisted',\n        text: 'Removed from marketplace',\n        flaggedAt: entry.flaggedAt,\n      })\n    }\n\n    // Sort scopes and build final list\n    const sortedScopes = [...itemsByScope.keys()].sort(\n      (a, b) => (scopeOrder[a] ?? 99) - (scopeOrder[b] ?? 99),\n    )\n\n    for (const scope of sortedScopes) {\n      const items = itemsByScope.get(scope)!\n\n      // Separate items into plugin groups (with their child MCPs) and standalone MCPs\n      // This preserves parent-child relationships that would be broken by naive sorting\n      const pluginGroups: UnifiedInstalledItem[][] = []\n      const standaloneMcpsInScope: UnifiedInstalledItem[] = []\n\n      let i = 0\n      while (i < items.length) {\n        const item = items[i]!\n        if (\n          item.type === 'plugin' ||\n          item.type === 'failed-plugin' ||\n          item.type === 'flagged-plugin'\n        ) {\n          // Collect the plugin and its child MCPs as a group\n          const group: UnifiedInstalledItem[] = [item]\n          i++\n          // Look ahead for indented child MCPs\n          let nextItem = items[i]\n          while (nextItem?.type === 'mcp' && nextItem.indented) {\n            group.push(nextItem)\n            i++\n            nextItem = items[i]\n          }\n          pluginGroups.push(group)\n        } else if (item.type === 'mcp' && !item.indented) {\n          // Standalone MCP (not a child of a plugin)\n          standaloneMcpsInScope.push(item)\n          i++\n        } else {\n          // Skip orphaned indented MCPs (shouldn't happen)\n          i++\n        }\n      }\n\n      // Sort plugin groups by the plugin name (first item in each group)\n      pluginGroups.sort((a, b) => a[0]!.name.localeCompare(b[0]!.name))\n\n      // Sort standalone MCPs by name\n      standaloneMcpsInScope.sort((a, b) => a.name.localeCompare(b.name))\n\n      // Build final list: plugins (with their children) first, then standalone MCPs\n      for (const group of pluginGroups) {\n        unified.push(...group)\n      }\n      unified.push(...standaloneMcpsInScope)\n    }\n\n    return unified\n  }, [pluginStates, mcpClients, pluginErrors, pendingToggles, flaggedPlugins])\n\n  // Mark flagged plugins as seen when the Installed view renders them.\n  // After 48 hours from seenAt, they auto-clear on next load.\n  const flaggedIds = useMemo(\n    () =>\n      unifiedItems\n        .filter(item => item.type === 'flagged-plugin')\n        .map(item => item.id),\n    [unifiedItems],\n  )\n  useEffect(() => {\n    if (flaggedIds.length > 0) {\n      void markFlaggedPluginsSeen(flaggedIds)\n    }\n  }, [flaggedIds])\n\n  // Filter items based on search query (matches name or description)\n  const filteredItems = useMemo(() => {\n    if (!searchQuery) return unifiedItems\n    const lowerQuery = searchQuery.toLowerCase()\n    return unifiedItems.filter(\n      item =>\n        item.name.toLowerCase().includes(lowerQuery) ||\n        ('description' in item &&\n          item.description?.toLowerCase().includes(lowerQuery)),\n    )\n  }, [unifiedItems, searchQuery])\n\n  // Selection state\n  const [selectedIndex, setSelectedIndex] = useState(0)\n\n  // Pagination for unified list (continuous scrolling)\n  const pagination = usePagination<UnifiedInstalledItem>({\n    totalItems: filteredItems.length,\n    selectedIndex,\n    maxVisible: 8,\n  })\n\n  // Details view state\n  const [detailsMenuIndex, setDetailsMenuIndex] = useState(0)\n  const [isProcessing, setIsProcessing] = useState(false)\n  const [processError, setProcessError] = useState<string | null>(null)\n\n  // Configuration state\n  const [configNeeded, setConfigNeeded] =\n    useState<McpbNeedsConfigResult | null>(null)\n  const [_isLoadingConfig, setIsLoadingConfig] = useState(false)\n  const [selectedPluginHasMcpb, setSelectedPluginHasMcpb] = useState(false)\n\n  // Detect if selected plugin has MCPB\n  // Reads raw marketplace.json to work with old cached marketplaces\n  useEffect(() => {\n    if (!selectedPlugin) {\n      setSelectedPluginHasMcpb(false)\n      return\n    }\n\n    async function detectMcpb() {\n      // Check plugin manifest first\n      const mcpServersSpec = selectedPlugin!.plugin.manifest.mcpServers\n      let hasMcpb = false\n\n      if (mcpServersSpec) {\n        hasMcpb =\n          (typeof mcpServersSpec === 'string' &&\n            isMcpbSource(mcpServersSpec)) ||\n          (Array.isArray(mcpServersSpec) &&\n            mcpServersSpec.some(s => typeof s === 'string' && isMcpbSource(s)))\n      }\n\n      // If not in manifest, read raw marketplace.json directly (bypassing schema validation)\n      // This works even with old cached marketplaces from before MCPB support\n      if (!hasMcpb) {\n        try {\n          const marketplaceDir = path.join(selectedPlugin!.plugin.path, '..')\n          const marketplaceJsonPath = path.join(\n            marketplaceDir,\n            '.claude-plugin',\n            'marketplace.json',\n          )\n\n          const content = await fs.readFile(marketplaceJsonPath, 'utf-8')\n          const marketplace = jsonParse(content)\n\n          const entry = marketplace.plugins?.find(\n            (p: { name: string }) => p.name === selectedPlugin!.plugin.name,\n          )\n\n          if (entry?.mcpServers) {\n            const spec = entry.mcpServers\n            hasMcpb =\n              (typeof spec === 'string' && isMcpbSource(spec)) ||\n              (Array.isArray(spec) &&\n                spec.some(\n                  (s: unknown) => typeof s === 'string' && isMcpbSource(s),\n                ))\n          }\n        } catch (err) {\n          logForDebugging(`Failed to read raw marketplace.json: ${err}`)\n        }\n      }\n\n      setSelectedPluginHasMcpb(hasMcpb)\n    }\n\n    void detectMcpb()\n  }, [selectedPlugin])\n\n  // Load installed plugins grouped by marketplace\n  useEffect(() => {\n    async function loadInstalledPlugins() {\n      setLoading(true)\n      try {\n        const { enabled, disabled } = await loadAllPlugins()\n        const mergedSettings = getSettings_DEPRECATED() // Use merged settings to respect all layers\n\n        const allPlugins = filterManagedDisabledPlugins([\n          ...enabled,\n          ...disabled,\n        ])\n\n        // Group plugins by marketplace\n        const pluginsByMarketplace: Record<string, LoadedPlugin[]> = {}\n        for (const plugin of allPlugins) {\n          const marketplace = plugin.source.split('@')[1] || 'local'\n          if (!pluginsByMarketplace[marketplace]) {\n            pluginsByMarketplace[marketplace] = []\n          }\n          pluginsByMarketplace[marketplace]!.push(plugin)\n        }\n\n        // Create marketplace info array with enabled/disabled counts\n        const marketplaceInfos: MarketplaceInfo[] = []\n        for (const [name, plugins] of Object.entries(pluginsByMarketplace)) {\n          const enabledCount = count(plugins, p => {\n            const pluginId = `${p.name}@${name}`\n            return mergedSettings?.enabledPlugins?.[pluginId] !== false\n          })\n          const disabledCount = plugins.length - enabledCount\n\n          marketplaceInfos.push({\n            name,\n            installedPlugins: plugins,\n            enabledCount,\n            disabledCount,\n          })\n        }\n\n        // Sort marketplaces: claude-plugin-directory first, then alphabetically\n        marketplaceInfos.sort((a, b) => {\n          if (a.name === 'claude-plugin-directory') return -1\n          if (b.name === 'claude-plugin-directory') return 1\n          return a.name.localeCompare(b.name)\n        })\n\n        setMarketplaces(marketplaceInfos)\n\n        // Build flat list of all plugin states\n        const allStates: PluginState[] = []\n        for (const marketplace of marketplaceInfos) {\n          for (const plugin of marketplace.installedPlugins) {\n            const pluginId = `${plugin.name}@${marketplace.name}`\n            // Built-in plugins don't have V2 install entries — skip the lookup.\n            const scope = plugin.isBuiltin\n              ? 'builtin'\n              : getPluginInstallationFromV2(pluginId).scope\n\n            allStates.push({\n              plugin,\n              marketplace: marketplace.name,\n              scope,\n              pendingEnable: undefined,\n              pendingUpdate: false,\n            })\n          }\n        }\n        setPluginStates(allStates)\n        setSelectedIndex(0)\n      } finally {\n        setLoading(false)\n      }\n    }\n\n    void loadInstalledPlugins()\n  }, [])\n\n  // Auto-navigate to target plugin if specified (once only)\n  useEffect(() => {\n    if (hasAutoNavigated.current) return\n    if (targetPlugin && marketplaces.length > 0 && !loading) {\n      // targetPlugin may be `name` or `name@marketplace` (parseArgs passes the\n      // raw arg through). Parse it so p.name matching works either way.\n      const { name: targetName, marketplace: targetMktFromId } =\n        parsePluginIdentifier(targetPlugin)\n      const effectiveTargetMarketplace = targetMarketplace ?? targetMktFromId\n\n      // Use targetMarketplace if provided, otherwise search all\n      const marketplacesToSearch = effectiveTargetMarketplace\n        ? marketplaces.filter(m => m.name === effectiveTargetMarketplace)\n        : marketplaces\n\n      // First check successfully loaded plugins\n      for (const marketplace of marketplacesToSearch) {\n        const plugin = marketplace.installedPlugins.find(\n          p => p.name === targetName,\n        )\n        if (plugin) {\n          // Get scope from V2 data for proper operation handling\n          const pluginId = `${plugin.name}@${marketplace.name}`\n          const { scope } = getPluginInstallationFromV2(pluginId)\n\n          const pluginState: PluginState = {\n            plugin,\n            marketplace: marketplace.name,\n            scope,\n            pendingEnable: undefined,\n            pendingUpdate: false,\n          }\n          setSelectedPlugin(pluginState)\n          setViewState('plugin-details')\n          pendingAutoActionRef.current = action\n          hasAutoNavigated.current = true\n          return\n        }\n      }\n\n      // Fall back to failed plugins (those with errors but not loaded)\n      const failedItem = unifiedItems.find(\n        item => item.type === 'failed-plugin' && item.name === targetName,\n      )\n      if (failedItem && failedItem.type === 'failed-plugin') {\n        setViewState({\n          type: 'failed-plugin-details',\n          plugin: {\n            id: failedItem.id,\n            name: failedItem.name,\n            marketplace: failedItem.marketplace,\n            errors: failedItem.errors,\n            scope: failedItem.scope,\n          },\n        })\n        hasAutoNavigated.current = true\n      }\n\n      // No match in loaded OR failed plugins — close the dialog with a\n      // message rather than silently landing on the plugin list. Only do\n      // this when an action was requested (e.g. /plugin uninstall X);\n      // plain navigation (/plugin manage) should still just show the list.\n      if (!hasAutoNavigated.current && action) {\n        hasAutoNavigated.current = true\n        setResult(`Plugin \"${targetPlugin}\" is not installed in this project`)\n      }\n    }\n  }, [\n    targetPlugin,\n    targetMarketplace,\n    marketplaces,\n    loading,\n    unifiedItems,\n    action,\n    setResult,\n  ])\n\n  // Handle single plugin operations from details view\n  const handleSingleOperation = async (\n    operation: 'enable' | 'disable' | 'update' | 'uninstall',\n  ) => {\n    if (!selectedPlugin) return\n\n    const pluginScope = selectedPlugin.scope || 'user'\n    const isBuiltin = pluginScope === 'builtin'\n\n    // Built-in plugins can only be enabled/disabled, not updated/uninstalled.\n    if (isBuiltin && (operation === 'update' || operation === 'uninstall')) {\n      setProcessError('Built-in plugins cannot be updated or uninstalled.')\n      return\n    }\n\n    // Managed scope plugins can only be updated, not enabled/disabled/uninstalled\n    if (\n      !isBuiltin &&\n      !isInstallableScope(pluginScope) &&\n      operation !== 'update'\n    ) {\n      setProcessError(\n        'This plugin is managed by your organization. Contact your admin to disable it.',\n      )\n      return\n    }\n\n    setIsProcessing(true)\n    setProcessError(null)\n\n    try {\n      const pluginId = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`\n      let reverseDependents: string[] | undefined\n\n      // enable/disable omit scope — pluginScope is the install scope from\n      // installed_plugins.json (where files are cached), which can diverge\n      // from the settings scope (where enablement lives). Passing it trips\n      // the cross-scope guard. Auto-detect finds the right scope. #38084\n      switch (operation) {\n        case 'enable': {\n          const enableResult = await enablePluginOp(pluginId)\n          if (!enableResult.success) {\n            throw new Error(enableResult.message)\n          }\n          break\n        }\n        case 'disable': {\n          const disableResult = await disablePluginOp(pluginId)\n          if (!disableResult.success) {\n            throw new Error(disableResult.message)\n          }\n          reverseDependents = disableResult.reverseDependents\n          break\n        }\n        case 'uninstall': {\n          if (isBuiltin) break // guarded above; narrows pluginScope\n          if (!isInstallableScope(pluginScope)) break\n          // If the plugin is enabled in .claude/settings.json (shared with the\n          // team), divert to a confirmation dialog that offers to disable in\n          // settings.local.json instead. Check the settings file directly —\n          // `pluginScope` (from installed_plugins.json) can be 'user' even when\n          // the plugin is ALSO project-enabled, and uninstalling the user-scope\n          // install would leave the project enablement active.\n          if (isPluginEnabledAtProjectScope(pluginId)) {\n            setIsProcessing(false)\n            setViewState('confirm-project-uninstall')\n            return\n          }\n          // If the plugin has persistent data (${CLAUDE_PLUGIN_DATA}) AND this\n          // is the last scope, prompt before deleting it. For multi-scope\n          // installs, the op's isLastScope check won't delete regardless of\n          // the user's y/n — showing the dialog would mislead (\"y\" → nothing\n          // happens). Length check mirrors pluginOperations.ts:513.\n          const installs = loadInstalledPluginsV2().plugins[pluginId]\n          const isLastScope = !installs || installs.length <= 1\n          const dataSize = isLastScope\n            ? await getPluginDataDirSize(pluginId)\n            : null\n          if (dataSize) {\n            setIsProcessing(false)\n            setViewState({ type: 'confirm-data-cleanup', size: dataSize })\n            return\n          }\n          const result = await uninstallPluginOp(pluginId, pluginScope)\n          if (!result.success) {\n            throw new Error(result.message)\n          }\n          reverseDependents = result.reverseDependents\n          break\n        }\n        case 'update': {\n          if (isBuiltin) break // guarded above; narrows pluginScope\n          const result = await updatePluginOp(pluginId, pluginScope)\n          if (!result.success) {\n            throw new Error(result.message)\n          }\n          // If already up to date, show message and exit\n          if (result.alreadyUpToDate) {\n            setResult(\n              `${selectedPlugin.plugin.name} is already at the latest version (${result.newVersion}).`,\n            )\n            if (onManageComplete) {\n              await onManageComplete()\n            }\n            setParentViewState({ type: 'menu' })\n            return\n          }\n          // Success - will show standard message below\n          break\n        }\n      }\n\n      // Operations (enable, disable, uninstall, update) now use centralized functions\n      // that handle their own settings updates, so we only need to clear caches here\n      clearAllCaches()\n\n      // Prompt for manifest.userConfig + channel userConfig if the plugin ends\n      // up enabled. Re-read settings rather than keying on `operation ===\n      // 'enable'`: install enables on install, so the menu shows \"Disable\"\n      // first. PluginOptionsFlow itself checks getUnconfiguredOptions — if\n      // nothing needs filling, it calls onDone('skipped') immediately.\n      const pluginIdNow = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`\n      const settingsAfter = getSettings_DEPRECATED()\n      const enabledAfter =\n        settingsAfter?.enabledPlugins?.[pluginIdNow] !== false\n      if (enabledAfter) {\n        setIsProcessing(false)\n        setViewState({ type: 'plugin-options' })\n        return\n      }\n\n      const operationName =\n        operation === 'enable'\n          ? 'Enabled'\n          : operation === 'disable'\n            ? 'Disabled'\n            : operation === 'update'\n              ? 'Updated'\n              : 'Uninstalled'\n\n      // Single-line warning — notification timeout is ~8s, multi-line would scroll off.\n      // The persistent record is in the Errors tab (dependency-unsatisfied after reload).\n      const depWarn =\n        reverseDependents && reverseDependents.length > 0\n          ? ` · required by ${reverseDependents.join(', ')}`\n          : ''\n      const message = `✓ ${operationName} ${selectedPlugin.plugin.name}${depWarn}. Run /reload-plugins to apply.`\n      setResult(message)\n\n      if (onManageComplete) {\n        await onManageComplete()\n      }\n\n      setParentViewState({ type: 'menu' })\n    } catch (error) {\n      setIsProcessing(false)\n      const errorMessage =\n        error instanceof Error ? error.message : String(error)\n      setProcessError(`Failed to ${operation}: ${errorMessage}`)\n      logError(toError(error))\n    }\n  }\n\n  // Latest-ref: lets the auto-action effect call the current closure without\n  // adding handleSingleOperation (recreated every render) to its deps.\n  const handleSingleOperationRef = useRef(handleSingleOperation)\n  handleSingleOperationRef.current = handleSingleOperation\n\n  // Auto-execute the action prop (/plugin uninstall X, /plugin enable X, etc.)\n  // once auto-navigation has landed on plugin-details.\n  useEffect(() => {\n    if (\n      viewState === 'plugin-details' &&\n      selectedPlugin &&\n      pendingAutoActionRef.current\n    ) {\n      const pending = pendingAutoActionRef.current\n      pendingAutoActionRef.current = undefined\n      void handleSingleOperationRef.current(pending)\n    }\n  }, [viewState, selectedPlugin])\n\n  // Handle toggle enable/disable\n  const handleToggle = React.useCallback(() => {\n    if (selectedIndex >= filteredItems.length) return\n    const item = filteredItems[selectedIndex]\n    if (item?.type === 'flagged-plugin') return\n    if (item?.type === 'plugin') {\n      const pluginId = `${item.plugin.name}@${item.marketplace}`\n      const mergedSettings = getSettings_DEPRECATED()\n      const currentPending = pendingToggles.get(pluginId)\n      const isEnabled = mergedSettings?.enabledPlugins?.[pluginId] !== false\n      const pluginScope = item.scope\n      const isBuiltin = pluginScope === 'builtin'\n      if (isBuiltin || isInstallableScope(pluginScope)) {\n        const newPending = new Map(pendingToggles)\n        // Omit scope — see handleSingleOperation's enable/disable comment.\n        if (currentPending) {\n          // Cancel: reverse the operation back to the original state\n          newPending.delete(pluginId)\n          void (async () => {\n            try {\n              if (currentPending === 'will-disable') {\n                await enablePluginOp(pluginId)\n              } else {\n                await disablePluginOp(pluginId)\n              }\n              clearAllCaches()\n            } catch (err) {\n              logError(err)\n            }\n          })()\n        } else {\n          newPending.set(pluginId, isEnabled ? 'will-disable' : 'will-enable')\n          void (async () => {\n            try {\n              if (isEnabled) {\n                await disablePluginOp(pluginId)\n              } else {\n                await enablePluginOp(pluginId)\n              }\n              clearAllCaches()\n            } catch (err) {\n              logError(err)\n            }\n          })()\n        }\n        setPendingToggles(newPending)\n      }\n    } else if (item?.type === 'mcp') {\n      void toggleMcpServer(item.client.name)\n    }\n  }, [\n    selectedIndex,\n    filteredItems,\n    pendingToggles,\n    pluginStates,\n    toggleMcpServer,\n  ])\n\n  // Handle accept (Enter) in plugin-list\n  const handleAccept = React.useCallback(() => {\n    if (selectedIndex >= filteredItems.length) return\n    const item = filteredItems[selectedIndex]\n    if (item?.type === 'plugin') {\n      const state = pluginStates.find(\n        s =>\n          s.plugin.name === item.plugin.name &&\n          s.marketplace === item.marketplace,\n      )\n      if (state) {\n        setSelectedPlugin(state)\n        setViewState('plugin-details')\n        setDetailsMenuIndex(0)\n        setProcessError(null)\n      }\n    } else if (item?.type === 'flagged-plugin') {\n      setViewState({\n        type: 'flagged-detail',\n        plugin: {\n          id: item.id,\n          name: item.name,\n          marketplace: item.marketplace,\n          reason: item.reason,\n          text: item.text,\n          flaggedAt: item.flaggedAt,\n        },\n      })\n      setProcessError(null)\n    } else if (item?.type === 'failed-plugin') {\n      setViewState({\n        type: 'failed-plugin-details',\n        plugin: {\n          id: item.id,\n          name: item.name,\n          marketplace: item.marketplace,\n          errors: item.errors,\n          scope: item.scope,\n        },\n      })\n      setDetailsMenuIndex(0)\n      setProcessError(null)\n    } else if (item?.type === 'mcp') {\n      setViewState({ type: 'mcp-detail', client: item.client })\n      setProcessError(null)\n    }\n  }, [selectedIndex, filteredItems, pluginStates])\n\n  // Plugin-list navigation (non-search mode)\n  useKeybindings(\n    {\n      'select:previous': () => {\n        if (selectedIndex === 0) {\n          setIsSearchMode(true)\n        } else {\n          pagination.handleSelectionChange(selectedIndex - 1, setSelectedIndex)\n        }\n      },\n      'select:next': () => {\n        if (selectedIndex < filteredItems.length - 1) {\n          pagination.handleSelectionChange(selectedIndex + 1, setSelectedIndex)\n        }\n      },\n      'select:accept': handleAccept,\n    },\n    {\n      context: 'Select',\n      isActive: viewState === 'plugin-list' && !isSearchMode,\n    },\n  )\n\n  useKeybindings(\n    { 'plugin:toggle': handleToggle },\n    {\n      context: 'Plugin',\n      isActive: viewState === 'plugin-list' && !isSearchMode,\n    },\n  )\n\n  // Handle dismiss action in flagged-detail view\n  const handleFlaggedDismiss = React.useCallback(() => {\n    if (typeof viewState !== 'object' || viewState.type !== 'flagged-detail')\n      return\n    void removeFlaggedPlugin(viewState.plugin.id)\n    setViewState('plugin-list')\n  }, [viewState])\n\n  useKeybindings(\n    { 'select:accept': handleFlaggedDismiss },\n    {\n      context: 'Select',\n      isActive:\n        typeof viewState === 'object' && viewState.type === 'flagged-detail',\n    },\n  )\n\n  // Build details menu items (needed for navigation)\n  const detailsMenuItems = React.useMemo(() => {\n    if (viewState !== 'plugin-details' || !selectedPlugin) return []\n\n    const mergedSettings = getSettings_DEPRECATED()\n    const pluginId = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`\n    const isEnabled = mergedSettings?.enabledPlugins?.[pluginId] !== false\n    const isBuiltin = selectedPlugin.marketplace === 'builtin'\n\n    const menuItems: Array<{ label: string; action: () => void }> = []\n\n    menuItems.push({\n      label: isEnabled ? 'Disable plugin' : 'Enable plugin',\n      action: () =>\n        void handleSingleOperation(isEnabled ? 'disable' : 'enable'),\n    })\n\n    // Update/Uninstall options — not available for built-in plugins\n    if (!isBuiltin) {\n      menuItems.push({\n        label: selectedPlugin.pendingUpdate\n          ? 'Unmark for update'\n          : 'Mark for update',\n        action: async () => {\n          try {\n            const localError = await checkIfLocalPlugin(\n              selectedPlugin.plugin.name,\n              selectedPlugin.marketplace,\n            )\n\n            if (localError) {\n              setProcessError(localError)\n              return\n            }\n\n            const newStates = [...pluginStates]\n            const index = newStates.findIndex(\n              s =>\n                s.plugin.name === selectedPlugin.plugin.name &&\n                s.marketplace === selectedPlugin.marketplace,\n            )\n            if (index !== -1) {\n              newStates[index]!.pendingUpdate = !selectedPlugin.pendingUpdate\n              setPluginStates(newStates)\n              setSelectedPlugin({\n                ...selectedPlugin,\n                pendingUpdate: !selectedPlugin.pendingUpdate,\n              })\n            }\n          } catch (error) {\n            setProcessError(\n              error instanceof Error\n                ? error.message\n                : 'Failed to check plugin update availability',\n            )\n          }\n        },\n      })\n\n      if (selectedPluginHasMcpb) {\n        menuItems.push({\n          label: 'Configure',\n          action: async () => {\n            setIsLoadingConfig(true)\n            try {\n              const mcpServersSpec = selectedPlugin.plugin.manifest.mcpServers\n\n              let mcpbPath: string | null = null\n              if (\n                typeof mcpServersSpec === 'string' &&\n                isMcpbSource(mcpServersSpec)\n              ) {\n                mcpbPath = mcpServersSpec\n              } else if (Array.isArray(mcpServersSpec)) {\n                for (const spec of mcpServersSpec) {\n                  if (typeof spec === 'string' && isMcpbSource(spec)) {\n                    mcpbPath = spec\n                    break\n                  }\n                }\n              }\n\n              if (!mcpbPath) {\n                setProcessError('No MCPB file found in plugin')\n                setIsLoadingConfig(false)\n                return\n              }\n\n              const pluginId = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`\n              const result = await loadMcpbFile(\n                mcpbPath,\n                selectedPlugin.plugin.path,\n                pluginId,\n                undefined,\n                undefined,\n                true,\n              )\n\n              if ('status' in result && result.status === 'needs-config') {\n                setConfigNeeded(result)\n                setViewState('configuring')\n              } else {\n                setProcessError('Failed to load MCPB for configuration')\n              }\n            } catch (err) {\n              const errorMsg = errorMessage(err)\n              setProcessError(`Failed to load configuration: ${errorMsg}`)\n            } finally {\n              setIsLoadingConfig(false)\n            }\n          },\n        })\n      }\n\n      if (\n        selectedPlugin.plugin.manifest.userConfig &&\n        Object.keys(selectedPlugin.plugin.manifest.userConfig).length > 0\n      ) {\n        menuItems.push({\n          label: 'Configure options',\n          action: () => {\n            setViewState({\n              type: 'configuring-options',\n              schema: selectedPlugin.plugin.manifest.userConfig!,\n            })\n          },\n        })\n      }\n\n      menuItems.push({\n        label: 'Update now',\n        action: () => void handleSingleOperation('update'),\n      })\n\n      menuItems.push({\n        label: 'Uninstall',\n        action: () => void handleSingleOperation('uninstall'),\n      })\n    }\n\n    if (selectedPlugin.plugin.manifest.homepage) {\n      menuItems.push({\n        label: 'Open homepage',\n        action: () =>\n          void openBrowser(selectedPlugin.plugin.manifest.homepage!),\n      })\n    }\n\n    if (selectedPlugin.plugin.manifest.repository) {\n      menuItems.push({\n        // Generic label — manifest.repository can be GitLab, Bitbucket,\n        // Azure DevOps, etc. (gh-31598). pluginDetailsHelpers.tsx:74 keeps\n        // 'View on GitHub' because that path has an explicit isGitHub check.\n        label: 'View repository',\n        action: () =>\n          void openBrowser(selectedPlugin.plugin.manifest.repository!),\n      })\n    }\n\n    menuItems.push({\n      label: 'Back to plugin list',\n      action: () => {\n        setViewState('plugin-list')\n        setSelectedPlugin(null)\n        setProcessError(null)\n      },\n    })\n\n    return menuItems\n  }, [viewState, selectedPlugin, selectedPluginHasMcpb, pluginStates])\n\n  // Plugin-details navigation\n  useKeybindings(\n    {\n      'select:previous': () => {\n        if (detailsMenuIndex > 0) {\n          setDetailsMenuIndex(detailsMenuIndex - 1)\n        }\n      },\n      'select:next': () => {\n        if (detailsMenuIndex < detailsMenuItems.length - 1) {\n          setDetailsMenuIndex(detailsMenuIndex + 1)\n        }\n      },\n      'select:accept': () => {\n        if (detailsMenuItems[detailsMenuIndex]) {\n          detailsMenuItems[detailsMenuIndex]!.action()\n        }\n      },\n    },\n    {\n      context: 'Select',\n      isActive: viewState === 'plugin-details' && !!selectedPlugin,\n    },\n  )\n\n  // Failed-plugin-details: only \"Uninstall\" option, handle Enter\n  useKeybindings(\n    {\n      'select:accept': () => {\n        if (\n          typeof viewState === 'object' &&\n          viewState.type === 'failed-plugin-details'\n        ) {\n          void (async () => {\n            setIsProcessing(true)\n            setProcessError(null)\n            const pluginId = viewState.plugin.id\n            const pluginScope = viewState.plugin.scope\n            // Pass scope to uninstallPluginOp so it can find the correct V2\n            // installation record and clean up on-disk files. Fall back to\n            // default scope if not installable (e.g. 'managed', though that\n            // case is guarded by isActive below). deleteDataDir=false: this\n            // is a recovery path for a plugin that failed to load — it may\n            // be reinstallable, so don't nuke ${CLAUDE_PLUGIN_DATA} silently.\n            // The normal uninstall path prompts; this one preserves.\n            const result = isInstallableScope(pluginScope)\n              ? await uninstallPluginOp(pluginId, pluginScope, false)\n              : await uninstallPluginOp(pluginId, 'user', false)\n            let success = result.success\n            if (!success) {\n              // Plugin was never installed (only in enabledPlugins settings).\n              // Remove directly from all editable settings sources.\n              const editableSources = [\n                'userSettings' as const,\n                'projectSettings' as const,\n                'localSettings' as const,\n              ]\n              for (const source of editableSources) {\n                const settings = getSettingsForSource(source)\n                if (settings?.enabledPlugins?.[pluginId] !== undefined) {\n                  updateSettingsForSource(source, {\n                    enabledPlugins: {\n                      ...settings.enabledPlugins,\n                      [pluginId]: undefined,\n                    },\n                  })\n                  success = true\n                }\n              }\n              // Clear memoized caches so next loadAllPlugins() picks up settings changes\n              clearAllCaches()\n            }\n            if (success) {\n              if (onManageComplete) {\n                await onManageComplete()\n              }\n              setIsProcessing(false)\n              // Return to list (don't setResult — that closes the whole dialog)\n              setViewState('plugin-list')\n            } else {\n              setIsProcessing(false)\n              setProcessError(result.message)\n            }\n          })()\n        }\n      },\n    },\n    {\n      context: 'Select',\n      isActive:\n        typeof viewState === 'object' &&\n        viewState.type === 'failed-plugin-details' &&\n        viewState.plugin.scope !== 'managed',\n    },\n  )\n\n  // Confirm-project-uninstall: y/enter disables in settings.local.json, n/escape cancels\n  useKeybindings(\n    {\n      'confirm:yes': () => {\n        if (!selectedPlugin) return\n        setIsProcessing(true)\n        setProcessError(null)\n        const pluginId = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`\n        // Write `false` directly — disablePluginOp's cross-scope guard would\n        // reject this (plugin isn't in localSettings yet; the override IS the\n        // point).\n        const { error } = updateSettingsForSource('localSettings', {\n          enabledPlugins: {\n            ...getSettingsForSource('localSettings')?.enabledPlugins,\n            [pluginId]: false,\n          },\n        })\n        if (error) {\n          setIsProcessing(false)\n          setProcessError(`Failed to write settings: ${error.message}`)\n          return\n        }\n        clearAllCaches()\n        setResult(\n          `✓ Disabled ${selectedPlugin.plugin.name} in .claude/settings.local.json. Run /reload-plugins to apply.`,\n        )\n        if (onManageComplete) void onManageComplete()\n        setParentViewState({ type: 'menu' })\n      },\n      'confirm:no': () => {\n        setViewState('plugin-details')\n        setProcessError(null)\n      },\n    },\n    {\n      context: 'Confirmation',\n      isActive:\n        viewState === 'confirm-project-uninstall' &&\n        !!selectedPlugin &&\n        !isProcessing,\n    },\n  )\n\n  // Confirm-data-cleanup: y uninstalls + deletes data dir, n uninstalls + keeps,\n  // esc cancels. Raw useInput because: (1) the Confirmation context maps\n  // enter→confirm:yes, which would make Enter delete the data directory — a\n  // destructive default the UI text (\"y to delete · n to keep\") doesn't\n  // advertise; (2) unlike confirm-project-uninstall (which uses useKeybindings\n  // where n and escape both map to confirm:no), here n and escape are DIFFERENT\n  // actions (keep-data vs cancel), so this deliberately stays on raw useInput.\n  // eslint-disable-next-line custom-rules/prefer-use-keybindings -- raw y/n/esc; Enter must not trigger destructive delete\n  useInput(\n    (input, key) => {\n      if (!selectedPlugin) return\n      const pluginId = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`\n      const pluginScope = selectedPlugin.scope\n      // Dialog is only reachable from the uninstall case (which guards on\n      // isBuiltin), but TS can't track that across viewState transitions.\n      if (\n        !pluginScope ||\n        pluginScope === 'builtin' ||\n        !isInstallableScope(pluginScope)\n      )\n        return\n      const doUninstall = async (deleteDataDir: boolean) => {\n        setIsProcessing(true)\n        setProcessError(null)\n        try {\n          const result = await uninstallPluginOp(\n            pluginId,\n            pluginScope,\n            deleteDataDir,\n          )\n          if (!result.success) throw new Error(result.message)\n          clearAllCaches()\n          const suffix = deleteDataDir ? '' : ' · data preserved'\n          setResult(`${figures.tick} ${result.message}${suffix}`)\n          if (onManageComplete) void onManageComplete()\n          setParentViewState({ type: 'menu' })\n        } catch (e) {\n          setIsProcessing(false)\n          setProcessError(e instanceof Error ? e.message : String(e))\n        }\n      }\n      if (input === 'y' || input === 'Y') {\n        void doUninstall(true)\n      } else if (input === 'n' || input === 'N') {\n        void doUninstall(false)\n      } else if (key.escape) {\n        setViewState('plugin-details')\n        setProcessError(null)\n      }\n    },\n    {\n      isActive:\n        typeof viewState === 'object' &&\n        viewState.type === 'confirm-data-cleanup' &&\n        !!selectedPlugin &&\n        !isProcessing,\n    },\n  )\n\n  // Reset selection when search query changes\n  React.useEffect(() => {\n    setSelectedIndex(0)\n  }, [searchQuery])\n\n  // Handle input for entering search mode (text input handled by useSearchInput hook)\n  // eslint-disable-next-line custom-rules/prefer-use-keybindings -- useInput needed for raw search mode text input\n  useInput(\n    (input, key) => {\n      const keyIsNotCtrlOrMeta = !key.ctrl && !key.meta\n      if (isSearchMode) {\n        // Text input is handled by useSearchInput hook\n        return\n      }\n\n      // Enter search mode with '/' or any printable character (except navigation keys)\n      if (input === '/' && keyIsNotCtrlOrMeta) {\n        setIsSearchMode(true)\n        setSearchQuery('')\n        setSelectedIndex(0)\n      } else if (\n        keyIsNotCtrlOrMeta &&\n        input.length > 0 &&\n        !/^\\s+$/.test(input) &&\n        input !== 'j' &&\n        input !== 'k' &&\n        input !== ' '\n      ) {\n        setIsSearchMode(true)\n        setSearchQuery(input)\n        setSelectedIndex(0)\n      }\n    },\n    { isActive: viewState === 'plugin-list' },\n  )\n\n  // Loading state\n  if (loading) {\n    return <Text>Loading installed plugins…</Text>\n  }\n\n  // No plugins or MCPs installed\n  if (unifiedItems.length === 0) {\n    return (\n      <Box flexDirection=\"column\">\n        <Box marginBottom={1}>\n          <Text bold>Manage plugins</Text>\n        </Box>\n        <Text>No plugins or MCP servers installed.</Text>\n        <Box marginTop={1}>\n          <Text dimColor>Esc to go back</Text>\n        </Box>\n      </Box>\n    )\n  }\n\n  if (\n    typeof viewState === 'object' &&\n    viewState.type === 'plugin-options' &&\n    selectedPlugin\n  ) {\n    const pluginId = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`\n    function finish(msg: string): void {\n      setResult(msg)\n      // Plugin is enabled regardless of whether config was saved or\n      // skipped — onManageComplete → markPluginsChanged → the\n      // persistent \"run /reload-plugins\" notice.\n      if (onManageComplete) {\n        void onManageComplete()\n      }\n      setParentViewState({ type: 'menu' })\n    }\n    return (\n      <PluginOptionsFlow\n        plugin={selectedPlugin.plugin}\n        pluginId={pluginId}\n        onDone={(outcome, detail) => {\n          switch (outcome) {\n            case 'configured':\n              finish(\n                `✓ Enabled and configured ${selectedPlugin.plugin.name}. Run /reload-plugins to apply.`,\n              )\n              break\n            case 'skipped':\n              finish(\n                `✓ Enabled ${selectedPlugin.plugin.name}. Run /reload-plugins to apply.`,\n              )\n              break\n            case 'error':\n              finish(`Failed to save configuration: ${detail}`)\n              break\n          }\n        }}\n      />\n    )\n  }\n\n  // Configure options (from the Manage menu)\n  if (\n    typeof viewState === 'object' &&\n    viewState.type === 'configuring-options' &&\n    selectedPlugin\n  ) {\n    const pluginId = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`\n    return (\n      <PluginOptionsDialog\n        title={`Configure ${selectedPlugin.plugin.name}`}\n        subtitle=\"Plugin options\"\n        configSchema={viewState.schema}\n        initialValues={loadPluginOptions(pluginId)}\n        onSave={values => {\n          try {\n            savePluginOptions(pluginId, values, viewState.schema)\n            clearAllCaches()\n            setResult(\n              'Configuration saved. Run /reload-plugins for changes to take effect.',\n            )\n          } catch (err) {\n            setProcessError(\n              `Failed to save configuration: ${errorMessage(err)}`,\n            )\n          }\n          setViewState('plugin-details')\n        }}\n        onCancel={() => setViewState('plugin-details')}\n      />\n    )\n  }\n\n  // Configuration view\n  if (viewState === 'configuring' && configNeeded && selectedPlugin) {\n    const pluginId = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`\n\n    async function handleSave(config: UserConfigValues) {\n      if (!configNeeded || !selectedPlugin) return\n\n      try {\n        // Find MCPB path again\n        const mcpServersSpec = selectedPlugin.plugin.manifest.mcpServers\n        let mcpbPath: string | null = null\n\n        if (\n          typeof mcpServersSpec === 'string' &&\n          isMcpbSource(mcpServersSpec)\n        ) {\n          mcpbPath = mcpServersSpec\n        } else if (Array.isArray(mcpServersSpec)) {\n          for (const spec of mcpServersSpec) {\n            if (typeof spec === 'string' && isMcpbSource(spec)) {\n              mcpbPath = spec\n              break\n            }\n          }\n        }\n\n        if (!mcpbPath) {\n          setProcessError('No MCPB file found')\n          setViewState('plugin-details')\n          return\n        }\n\n        // Reload with provided config\n        await loadMcpbFile(\n          mcpbPath,\n          selectedPlugin.plugin.path,\n          pluginId,\n          undefined,\n          config,\n        )\n\n        // Success - go back to details\n        setProcessError(null)\n        setConfigNeeded(null)\n        setViewState('plugin-details')\n        setResult(\n          'Configuration saved. Run /reload-plugins for changes to take effect.',\n        )\n      } catch (err) {\n        const errorMsg = errorMessage(err)\n        setProcessError(`Failed to save configuration: ${errorMsg}`)\n        setViewState('plugin-details')\n      }\n    }\n\n    function handleCancel() {\n      setConfigNeeded(null)\n      setViewState('plugin-details')\n    }\n\n    return (\n      <PluginOptionsDialog\n        title={`Configure ${configNeeded.manifest.name}`}\n        subtitle={`Plugin: ${selectedPlugin.plugin.name}`}\n        configSchema={configNeeded.configSchema}\n        initialValues={configNeeded.existingConfig}\n        onSave={handleSave}\n        onCancel={handleCancel}\n      />\n    )\n  }\n\n  // Flagged plugin detail view\n  if (typeof viewState === 'object' && viewState.type === 'flagged-detail') {\n    const fp = viewState.plugin\n    return (\n      <Box flexDirection=\"column\">\n        <Box>\n          <Text bold>\n            {fp.name} @ {fp.marketplace}\n          </Text>\n        </Box>\n\n        <Box marginBottom={1}>\n          <Text dimColor>Status: </Text>\n          <Text color=\"error\">Removed</Text>\n        </Box>\n\n        <Box marginBottom={1} flexDirection=\"column\">\n          <Text color=\"error\">\n            Removed from marketplace · reason: {fp.reason}\n          </Text>\n          <Text>{fp.text}</Text>\n          <Text dimColor>\n            Flagged on {new Date(fp.flaggedAt).toLocaleDateString()}\n          </Text>\n        </Box>\n\n        <Box marginTop={1} flexDirection=\"column\">\n          <Box>\n            <Text>{figures.pointer} </Text>\n            <Text color=\"suggestion\">Dismiss</Text>\n          </Box>\n        </Box>\n\n        <Byline>\n          <ConfigurableShortcutHint\n            action=\"select:accept\"\n            context=\"Select\"\n            fallback=\"Enter\"\n            description=\"dismiss\"\n          />\n          <ConfigurableShortcutHint\n            action=\"confirm:no\"\n            context=\"Confirmation\"\n            fallback=\"Esc\"\n            description=\"back\"\n          />\n        </Byline>\n      </Box>\n    )\n  }\n\n  // Confirm-project-uninstall: warn about shared .claude/settings.json,\n  // offer to disable in settings.local.json instead.\n  if (viewState === 'confirm-project-uninstall' && selectedPlugin) {\n    return (\n      <Box flexDirection=\"column\">\n        <Text bold color=\"warning\">\n          {selectedPlugin.plugin.name} is enabled in .claude/settings.json\n          (shared with your team)\n        </Text>\n        <Box marginTop={1} flexDirection=\"column\">\n          <Text>Disable it just for you in .claude/settings.local.json?</Text>\n          <Text dimColor>\n            This has the same effect as uninstalling, without affecting other\n            contributors.\n          </Text>\n        </Box>\n        {processError && (\n          <Box marginTop={1}>\n            <Text color=\"error\">{processError}</Text>\n          </Box>\n        )}\n        <Box marginTop={1}>\n          {isProcessing ? (\n            <Text dimColor>Disabling…</Text>\n          ) : (\n            <Byline>\n              <ConfigurableShortcutHint\n                action=\"confirm:yes\"\n                context=\"Confirmation\"\n                fallback=\"y\"\n                description=\"disable\"\n              />\n              <ConfigurableShortcutHint\n                action=\"confirm:no\"\n                context=\"Confirmation\"\n                fallback=\"Esc\"\n                description=\"cancel\"\n              />\n            </Byline>\n          )}\n        </Box>\n      </Box>\n    )\n  }\n\n  // Confirm-data-cleanup: prompt before deleting ${CLAUDE_PLUGIN_DATA} dir\n  if (\n    typeof viewState === 'object' &&\n    viewState.type === 'confirm-data-cleanup' &&\n    selectedPlugin\n  ) {\n    return (\n      <Box flexDirection=\"column\">\n        <Text bold>\n          {selectedPlugin.plugin.name} has {viewState.size.human} of persistent\n          data\n        </Text>\n        <Box marginTop={1} flexDirection=\"column\">\n          <Text>Delete it along with the plugin?</Text>\n          <Text dimColor>\n            {pluginDataDirPath(\n              `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`,\n            )}\n          </Text>\n        </Box>\n        {processError && (\n          <Box marginTop={1}>\n            <Text color=\"error\">{processError}</Text>\n          </Box>\n        )}\n        <Box marginTop={1}>\n          {isProcessing ? (\n            <Text dimColor>Uninstalling…</Text>\n          ) : (\n            <Text>\n              <Text bold>y</Text> to delete · <Text bold>n</Text> to keep ·{' '}\n              <Text bold>esc</Text> to cancel\n            </Text>\n          )}\n        </Box>\n      </Box>\n    )\n  }\n\n  // Plugin details view\n  if (viewState === 'plugin-details' && selectedPlugin) {\n    const mergedSettings = getSettings_DEPRECATED() // Use merged settings to respect all layers\n    const pluginId = `${selectedPlugin.plugin.name}@${selectedPlugin.marketplace}`\n    const isEnabled = mergedSettings?.enabledPlugins?.[pluginId] !== false\n\n    // Compute plugin errors section\n    const filteredPluginErrors = pluginErrors.filter(\n      e =>\n        ('plugin' in e && e.plugin === selectedPlugin.plugin.name) ||\n        e.source === pluginId ||\n        e.source.startsWith(`${selectedPlugin.plugin.name}@`),\n    )\n    const pluginErrorsSection =\n      filteredPluginErrors.length === 0 ? null : (\n        <Box flexDirection=\"column\" marginBottom={1}>\n          <Text bold color=\"error\">\n            {filteredPluginErrors.length}{' '}\n            {plural(filteredPluginErrors.length, 'error')}:\n          </Text>\n          {filteredPluginErrors.map((error, i) => {\n            const guidance = getErrorGuidance(error)\n            return (\n              <Box key={i} flexDirection=\"column\" marginLeft={2}>\n                <Text color=\"error\">{formatErrorMessage(error)}</Text>\n                {guidance && (\n                  <Text dimColor italic>\n                    {figures.arrowRight} {guidance}\n                  </Text>\n                )}\n              </Box>\n            )\n          })}\n        </Box>\n      )\n\n    return (\n      <Box flexDirection=\"column\">\n        <Box>\n          <Text bold>\n            {selectedPlugin.plugin.name} @ {selectedPlugin.marketplace}\n          </Text>\n        </Box>\n\n        {/* Scope */}\n        <Box>\n          <Text dimColor>Scope: </Text>\n          <Text>{selectedPlugin.scope || 'user'}</Text>\n        </Box>\n\n        {/* Plugin details */}\n        {selectedPlugin.plugin.manifest.version && (\n          <Box>\n            <Text dimColor>Version: </Text>\n            <Text>{selectedPlugin.plugin.manifest.version}</Text>\n          </Box>\n        )}\n\n        {selectedPlugin.plugin.manifest.description && (\n          <Box marginBottom={1}>\n            <Text>{selectedPlugin.plugin.manifest.description}</Text>\n          </Box>\n        )}\n\n        {selectedPlugin.plugin.manifest.author && (\n          <Box>\n            <Text dimColor>Author: </Text>\n            <Text>{selectedPlugin.plugin.manifest.author.name}</Text>\n          </Box>\n        )}\n\n        {/* Current status */}\n        <Box marginBottom={1}>\n          <Text dimColor>Status: </Text>\n          <Text color={isEnabled ? 'success' : 'warning'}>\n            {isEnabled ? 'Enabled' : 'Disabled'}\n          </Text>\n          {selectedPlugin.pendingUpdate && (\n            <Text color=\"suggestion\"> · Marked for update</Text>\n          )}\n        </Box>\n\n        {/* Installed components */}\n        <PluginComponentsDisplay\n          plugin={selectedPlugin.plugin}\n          marketplace={selectedPlugin.marketplace}\n        />\n\n        {/* Plugin errors */}\n        {pluginErrorsSection}\n\n        {/* Menu */}\n        <Box marginTop={1} flexDirection=\"column\">\n          {detailsMenuItems.map((item, index) => {\n            const isSelected = index === detailsMenuIndex\n\n            return (\n              <Box key={index}>\n                {isSelected && <Text>{figures.pointer} </Text>}\n                {!isSelected && <Text>{'  '}</Text>}\n                <Text\n                  bold={isSelected}\n                  color={\n                    item.label.includes('Uninstall')\n                      ? 'error'\n                      : item.label.includes('Update')\n                        ? 'suggestion'\n                        : undefined\n                  }\n                >\n                  {item.label}\n                </Text>\n              </Box>\n            )\n          })}\n        </Box>\n\n        {/* Processing state */}\n        {isProcessing && (\n          <Box marginTop={1}>\n            <Text>Processing…</Text>\n          </Box>\n        )}\n\n        {/* Error message */}\n        {processError && (\n          <Box marginTop={1}>\n            <Text color=\"error\">{processError}</Text>\n          </Box>\n        )}\n\n        <Box marginTop={1}>\n          <Text dimColor italic>\n            <Byline>\n              <ConfigurableShortcutHint\n                action=\"select:previous\"\n                context=\"Select\"\n                fallback=\"↑\"\n                description=\"navigate\"\n              />\n              <ConfigurableShortcutHint\n                action=\"select:accept\"\n                context=\"Select\"\n                fallback=\"Enter\"\n                description=\"select\"\n              />\n              <ConfigurableShortcutHint\n                action=\"confirm:no\"\n                context=\"Confirmation\"\n                fallback=\"Esc\"\n                description=\"back\"\n              />\n            </Byline>\n          </Text>\n        </Box>\n      </Box>\n    )\n  }\n\n  // Failed plugin detail view\n  if (\n    typeof viewState === 'object' &&\n    viewState.type === 'failed-plugin-details'\n  ) {\n    const failedPlugin = viewState.plugin\n\n    const firstError = failedPlugin.errors[0]\n    const errorMessage = firstError\n      ? formatErrorMessage(firstError)\n      : 'Failed to load'\n\n    return (\n      <Box flexDirection=\"column\">\n        <Text>\n          <Text bold>{failedPlugin.name}</Text>\n          <Text dimColor> @ {failedPlugin.marketplace}</Text>\n          <Text dimColor> ({failedPlugin.scope})</Text>\n        </Text>\n        <Text color=\"error\">{errorMessage}</Text>\n\n        {failedPlugin.scope === 'managed' ? (\n          <Box marginTop={1}>\n            <Text dimColor>\n              Managed by your organization — contact your admin\n            </Text>\n          </Box>\n        ) : (\n          <Box marginTop={1}>\n            <Text color=\"suggestion\">{figures.pointer} </Text>\n            <Text bold>Remove</Text>\n          </Box>\n        )}\n\n        {isProcessing && <Text>Processing…</Text>}\n        {processError && <Text color=\"error\">{processError}</Text>}\n\n        <Box marginTop={1}>\n          <Text dimColor italic>\n            <Byline>\n              {failedPlugin.scope !== 'managed' && (\n                <ConfigurableShortcutHint\n                  action=\"select:accept\"\n                  context=\"Select\"\n                  fallback=\"Enter\"\n                  description=\"remove\"\n                />\n              )}\n              <ConfigurableShortcutHint\n                action=\"confirm:no\"\n                context=\"Confirmation\"\n                fallback=\"Esc\"\n                description=\"back\"\n              />\n            </Byline>\n          </Text>\n        </Box>\n      </Box>\n    )\n  }\n\n  // MCP detail view\n  if (typeof viewState === 'object' && viewState.type === 'mcp-detail') {\n    const client = viewState.client\n    const serverToolsCount = filterToolsByServer(mcpTools, client.name).length\n\n    // Common handlers for MCP menus\n    const handleMcpViewTools = () => {\n      setViewState({ type: 'mcp-tools', client })\n    }\n\n    const handleMcpCancel = () => {\n      setViewState('plugin-list')\n    }\n\n    const handleMcpComplete = (result?: string) => {\n      if (result) {\n        setResult(result)\n      }\n      setViewState('plugin-list')\n    }\n\n    // Transform MCPServerConnection to appropriate ServerInfo type\n    const scope = client.config.scope\n    const configType = client.config.type\n\n    if (configType === 'stdio') {\n      const server: StdioServerInfo = {\n        name: client.name,\n        client,\n        scope,\n        transport: 'stdio',\n        config: client.config as McpStdioServerConfig,\n      }\n      return (\n        <MCPStdioServerMenu\n          server={server}\n          serverToolsCount={serverToolsCount}\n          onViewTools={handleMcpViewTools}\n          onCancel={handleMcpCancel}\n          onComplete={handleMcpComplete}\n          borderless\n        />\n      )\n    } else if (configType === 'sse') {\n      const server: SSEServerInfo = {\n        name: client.name,\n        client,\n        scope,\n        transport: 'sse',\n        isAuthenticated: undefined,\n        config: client.config as McpSSEServerConfig,\n      }\n      return (\n        <MCPRemoteServerMenu\n          server={server}\n          serverToolsCount={serverToolsCount}\n          onViewTools={handleMcpViewTools}\n          onCancel={handleMcpCancel}\n          onComplete={handleMcpComplete}\n          borderless\n        />\n      )\n    } else if (configType === 'http') {\n      const server: HTTPServerInfo = {\n        name: client.name,\n        client,\n        scope,\n        transport: 'http',\n        isAuthenticated: undefined,\n        config: client.config as McpHTTPServerConfig,\n      }\n      return (\n        <MCPRemoteServerMenu\n          server={server}\n          serverToolsCount={serverToolsCount}\n          onViewTools={handleMcpViewTools}\n          onCancel={handleMcpCancel}\n          onComplete={handleMcpComplete}\n          borderless\n        />\n      )\n    } else if (configType === 'claudeai-proxy') {\n      const server: ClaudeAIServerInfo = {\n        name: client.name,\n        client,\n        scope,\n        transport: 'claudeai-proxy',\n        isAuthenticated: undefined,\n        config: client.config as McpClaudeAIProxyServerConfig,\n      }\n      return (\n        <MCPRemoteServerMenu\n          server={server}\n          serverToolsCount={serverToolsCount}\n          onViewTools={handleMcpViewTools}\n          onCancel={handleMcpCancel}\n          onComplete={handleMcpComplete}\n          borderless\n        />\n      )\n    }\n\n    // Fallback - shouldn't happen but handle gracefully\n    setViewState('plugin-list')\n    return null\n  }\n\n  // MCP tools view\n  if (typeof viewState === 'object' && viewState.type === 'mcp-tools') {\n    const client = viewState.client\n    const scope = client.config.scope\n    const configType = client.config.type\n\n    // Build ServerInfo for MCPToolListView\n    let server:\n      | StdioServerInfo\n      | SSEServerInfo\n      | HTTPServerInfo\n      | ClaudeAIServerInfo\n    if (configType === 'stdio') {\n      server = {\n        name: client.name,\n        client,\n        scope,\n        transport: 'stdio',\n        config: client.config as McpStdioServerConfig,\n      }\n    } else if (configType === 'sse') {\n      server = {\n        name: client.name,\n        client,\n        scope,\n        transport: 'sse',\n        isAuthenticated: undefined,\n        config: client.config as McpSSEServerConfig,\n      }\n    } else if (configType === 'http') {\n      server = {\n        name: client.name,\n        client,\n        scope,\n        transport: 'http',\n        isAuthenticated: undefined,\n        config: client.config as McpHTTPServerConfig,\n      }\n    } else {\n      server = {\n        name: client.name,\n        client,\n        scope,\n        transport: 'claudeai-proxy',\n        isAuthenticated: undefined,\n        config: client.config as McpClaudeAIProxyServerConfig,\n      }\n    }\n\n    return (\n      <MCPToolListView\n        server={server}\n        onSelectTool={(tool: Tool) => {\n          setViewState({ type: 'mcp-tool-detail', client, tool })\n        }}\n        onBack={() => setViewState({ type: 'mcp-detail', client })}\n      />\n    )\n  }\n\n  // MCP tool detail view\n  if (typeof viewState === 'object' && viewState.type === 'mcp-tool-detail') {\n    const { client, tool } = viewState\n    const scope = client.config.scope\n    const configType = client.config.type\n\n    // Build ServerInfo for MCPToolDetailView\n    let server:\n      | StdioServerInfo\n      | SSEServerInfo\n      | HTTPServerInfo\n      | ClaudeAIServerInfo\n    if (configType === 'stdio') {\n      server = {\n        name: client.name,\n        client,\n        scope,\n        transport: 'stdio',\n        config: client.config as McpStdioServerConfig,\n      }\n    } else if (configType === 'sse') {\n      server = {\n        name: client.name,\n        client,\n        scope,\n        transport: 'sse',\n        isAuthenticated: undefined,\n        config: client.config as McpSSEServerConfig,\n      }\n    } else if (configType === 'http') {\n      server = {\n        name: client.name,\n        client,\n        scope,\n        transport: 'http',\n        isAuthenticated: undefined,\n        config: client.config as McpHTTPServerConfig,\n      }\n    } else {\n      server = {\n        name: client.name,\n        client,\n        scope,\n        transport: 'claudeai-proxy',\n        isAuthenticated: undefined,\n        config: client.config as McpClaudeAIProxyServerConfig,\n      }\n    }\n\n    return (\n      <MCPToolDetailView\n        tool={tool}\n        server={server}\n        onBack={() => setViewState({ type: 'mcp-tools', client })}\n      />\n    )\n  }\n\n  // Plugin list view (main management interface)\n  const visibleItems = pagination.getVisibleItems(filteredItems)\n\n  return (\n    <Box flexDirection=\"column\">\n      {/* Search box */}\n      <Box marginBottom={1}>\n        <SearchBox\n          query={searchQuery}\n          isFocused={isSearchMode}\n          isTerminalFocused={isTerminalFocused}\n          width={terminalWidth - 4}\n          cursorOffset={searchCursorOffset}\n        />\n      </Box>\n\n      {/* No search results */}\n      {filteredItems.length === 0 && searchQuery && (\n        <Box marginBottom={1}>\n          <Text dimColor>No items match &quot;{searchQuery}&quot;</Text>\n        </Box>\n      )}\n\n      {/* Scroll up indicator */}\n      {pagination.scrollPosition.canScrollUp && (\n        <Box>\n          <Text dimColor> {figures.arrowUp} more above</Text>\n        </Box>\n      )}\n\n      {/* Unified list of plugins and MCPs grouped by scope */}\n      {visibleItems.map((item, visibleIndex) => {\n        const actualIndex = pagination.toActualIndex(visibleIndex)\n        const isSelected = actualIndex === selectedIndex && !isSearchMode\n\n        // Check if we need to show a scope header\n        const prevItem =\n          visibleIndex > 0 ? visibleItems[visibleIndex - 1] : null\n        const showScopeHeader = !prevItem || prevItem.scope !== item.scope\n\n        // Get scope label\n        const getScopeLabel = (scope: string): string => {\n          switch (scope) {\n            case 'flagged':\n              return 'Flagged'\n            case 'project':\n              return 'Project'\n            case 'local':\n              return 'Local'\n            case 'user':\n              return 'User'\n            case 'enterprise':\n              return 'Enterprise'\n            case 'managed':\n              return 'Managed'\n            case 'builtin':\n              return 'Built-in'\n            case 'dynamic':\n              return 'Built-in'\n            default:\n              return scope\n          }\n        }\n\n        return (\n          <React.Fragment key={item.id}>\n            {showScopeHeader && (\n              <Box marginTop={visibleIndex > 0 ? 1 : 0} paddingLeft={2}>\n                <Text\n                  dimColor={item.scope !== 'flagged'}\n                  color={item.scope === 'flagged' ? 'warning' : undefined}\n                  bold={item.scope === 'flagged'}\n                >\n                  {getScopeLabel(item.scope)}\n                </Text>\n              </Box>\n            )}\n            <UnifiedInstalledCell item={item} isSelected={isSelected} />\n          </React.Fragment>\n        )\n      })}\n\n      {/* Scroll down indicator */}\n      {pagination.scrollPosition.canScrollDown && (\n        <Box>\n          <Text dimColor> {figures.arrowDown} more below</Text>\n        </Box>\n      )}\n\n      {/* Help text */}\n      <Box marginTop={1} marginLeft={1}>\n        <Text dimColor italic>\n          <Byline>\n            <Text>type to search</Text>\n            <ConfigurableShortcutHint\n              action=\"plugin:toggle\"\n              context=\"Plugin\"\n              fallback=\"Space\"\n              description=\"toggle\"\n            />\n            <ConfigurableShortcutHint\n              action=\"select:accept\"\n              context=\"Select\"\n              fallback=\"Enter\"\n              description=\"details\"\n            />\n            <ConfigurableShortcutHint\n              action=\"confirm:no\"\n              context=\"Confirmation\"\n              fallback=\"Esc\"\n              description=\"back\"\n            />\n          </Byline>\n        </Text>\n      </Box>\n\n      {/* Reload disclaimer for plugin changes */}\n      {pendingToggles.size > 0 && (\n        <Box marginLeft={1}>\n          <Text dimColor italic>\n            Run /reload-plugins to apply changes\n          </Text>\n        </Box>\n      )}\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]}