savant-code 0.0.19 → 0.0.20

package/cli/src/commands/command-registry.ts

@@ -1,1112 +0,0 @@
-import { CHATGPT_OAUTH_ENABLED } from '@savant-code/common/constants/chatgpt-oauth'
-import { runTerminalCommand } from '@savant-code/sdk'
-
-import { handleAdsEnable, handleAdsDisable } from './ads'
-import { handleCopyConversationCommand } from './copy-conversation'
-import { handleGoalCommand } from './goal'
-import { handleHealthCommand } from './health-command'
-import { handleHelpCommand } from './help'
-import { handleImageCommand } from './image'
-import { handleInitializationFlowLocally } from './init'
-import { handleLoopCommand } from './loop'
-import {
-  collectProcessDiagnostics,
-  formatProcessDiagnostics,
-} from './process-diagnostics'
-import {
-  buildInterviewPrompt,
-  buildPlanPrompt,
-  buildReviewPromptFromArgs,
-} from './prompt-builders'
-import { handleRewindCommand } from './rewind'
-import { runBashCommand } from './router'
-import { handleTelemetryCommand } from './telemetry'
-import { handleUsageCommand } from './usage'
-import { returnToSavantFreeLanding } from '../hooks/use-savant-free-session'
-import { useThemeStore } from '../hooks/use-theme'
-import { WEBSITE_URL } from '../login/constants'
-import { startNewChat } from '../project-files'
-import { useChatStore } from '../state/chat-store'
-import { useFeedbackStore } from '../state/feedback-store'
-import { useLoginStore } from '../state/login-store'
-import { useModelPickerStore } from '../state/model-picker-store'
-import { useProviderPickerStore } from '../state/provider-picker-store'
-import { useSavantFreeModelStore } from '../state/savant-free-model-store'
-import { abortActiveRun } from '../utils/active-run'
-import {
-  AGENT_MODES,
-  END_SESSION_MESSAGE,
-  IS_SAVANT_FREE,
-} from '../utils/constants'
-import { resetUiToIdle as _resetUiToIdle } from '../utils/finish-logic'
-import { getSystemMessage, getUserMessage } from '../utils/message-history'
-import { safeOpen } from '../utils/open-url'
-import { fetchGatewayModels } from '../utils/openrouter-models'
-import { capturePendingAttachments } from '../utils/pending-attachments'
-import {
-  beginProviderSetup,
-  getConfiguredProviderNames,
-  getProviderSetupInfo,
-  PROVIDER_SETUP_CONFIG,
-} from '../utils/provider-setup'
-import {
-  loadSavantCodeModelPreference,
-  saveSavantCodeModelPreference,
-  savePermissionModePreference,
-} from '../utils/settings'
-import { getSkillByName } from '../utils/skill-registry'
-
-import type { MultilineInputHandle } from '../components/multiline-input'
-import type { ChatMessage } from '../types/chat'
-import type { SendMessageFn } from '../types/contracts/send-message'
-import type { InputValue, PendingAttachment } from '../types/store'
-import type { User } from '../utils/auth'
-import type { AgentMode } from '../utils/constants'
-import type { UseMutationResult } from '@tanstack/react-query'
-
-// FID-2026-0718-010 (D3): helper for slash-command bridges. Calls
-// resetUiToIdle (which itself calls onStreamEnded) with the slash-command
-// reason. Gated by !isChainInProgress && !isRetrying inside finish-logic.
-const resetUiToIdleAfterSlashCommand = () => _resetUiToIdle('slash-command')
-
-export type RouterParams = {
-  abortControllerRef: React.MutableRefObject<AbortController | null>
-  agentMode: AgentMode
-  inputRef: React.MutableRefObject<MultilineInputHandle | null>
-  inputValue: string
-  isChainInProgressRef: React.MutableRefObject<boolean>
-  isStreaming: boolean
-  logoutMutation: UseMutationResult<boolean, Error, void, unknown>
-  streamMessageIdRef: React.MutableRefObject<string | null>
-  addToQueue: (message: string, attachments?: PendingAttachment[]) => void
-  clearMessages: () => void
-  saveToHistory: (message: string) => void
-  scrollToLatest: () => void
-  sendMessage: SendMessageFn
-  setCanProcessQueue: (value: React.SetStateAction<boolean>) => void
-  setInputFocused: (focused: boolean) => void
-  setInputValue: (
-    value: InputValue | ((prev: InputValue) => InputValue),
-  ) => void
-  setIsAuthenticated: (value: React.SetStateAction<boolean | null>) => void
-  setMessages: (
-    value: ChatMessage[] | ((prev: ChatMessage[]) => ChatMessage[]),
-  ) => void
-  setUser: (value: React.SetStateAction<User | null>) => void
-  stopStreaming: () => void
-}
-
-export type CommandResult = {
-  openFeedbackMode?: boolean
-  openPublishMode?: boolean
-  openChatHistory?: boolean
-  openReviewScreen?: boolean
-  preSelectAgents?: string[]
-} | void
-
-export type CommandHandler = (
-  params: RouterParams,
-  args: string,
-) => Promise<CommandResult> | CommandResult
-
-export type CommandDefinition = {
-  name: string
-  aliases: string[]
-  handler: CommandHandler
-  /** Whether this command accepts arguments. Set automatically by the factory functions. */
-  acceptsArgs: boolean
-}
-
-/**
- * Handler type for commands that don't accept arguments.
- */
-type CommandHandlerNoArgs = (
-  params: RouterParams,
-) => Promise<CommandResult> | CommandResult
-
-/**
- * Handler type for commands that accept arguments.
- */
-type CommandHandlerWithArgs = (
-  params: RouterParams,
-  args: string,
-) => Promise<CommandResult> | CommandResult
-
-/**
- * Configuration for defining a command that does NOT accept arguments.
- */
-type CommandConfig = {
-  name: string
-  aliases?: string[]
-  handler: CommandHandlerNoArgs
-}
-
-/**
- * Configuration for defining a command that accepts arguments.
- */
-type CommandWithArgsConfig = {
-  name: string
-  aliases?: string[]
-  handler: CommandHandlerWithArgs
-}
-
-/**
- * Factory for commands that do NOT accept arguments.
- * Any args passed are gracefully ignored.
- *
- * @example
- * defineCommand({
- *   name: 'new',
- *   aliases: ['n', 'clear'],
- *   handler: (params) => {
- *     params.setMessages(() => [])
- *   },
- * })
- */
-export function defineCommand(config: CommandConfig): CommandDefinition {
-  return {
-    name: config.name,
-    aliases: config.aliases ?? [],
-    acceptsArgs: false,
-    handler: (params) => {
-      // Args are gracefully ignored for commands that don't accept them
-      return config.handler(params)
-    },
-  }
-}
-
-/**
- * Factory for commands that accept arguments.
- * The handler receives both params and args.
- *
- * @example
- * defineCommandWithArgs({
- *   name: 'bash',
- *   aliases: ['!'],
- *   handler: (params, args) => {
- *     if (args.trim()) {
- *       runBashCommand(args.trim())
- *     }
- *   },
- * })
- */
-export function defineCommandWithArgs(
-  config: CommandWithArgsConfig,
-): CommandDefinition {
-  return {
-    name: config.name,
-    aliases: config.aliases ?? [],
-    acceptsArgs: true,
-    handler: config.handler,
-  }
-}
-
-const clearInput = (params: RouterParams) => {
-  params.setInputValue({ text: '', cursorPosition: 0, lastEditDueToNav: false })
-}
-
-const SAVANT_FREE_REMOVED_COMMANDS = new Set([
-  'ads:enable',
-  'ads:disable',
-  'usage',
-  'subscribe',
-  'image',
-  'publish',
-])
-
-const SAVANT_FREE_ONLY_COMMANDS = new Set(['connect', 'plan', 'end-session'])
-
-const ALL_COMMANDS: CommandDefinition[] = [
-  defineCommand({
-    name: 'ads:enable',
-    handler: (params) => {
-      const { postUserMessage } = handleAdsEnable()
-      // FID-007 P1: keep the reactive store slice in sync so slash-command
-      // filtering depends on it without re-reading settings per keystroke.
-      useChatStore.getState().setAdsEnabled(true)
-      params.setMessages((prev) => postUserMessage(prev))
-      params.saveToHistory(params.inputValue.trim())
-      clearInput(params)
-    },
-  }),
-  defineCommand({
-    name: 'ads:disable',
-    handler: (params) => {
-      const { postUserMessage } = handleAdsDisable()
-      // FID-007 P1: see ads:enable.
-      useChatStore.getState().setAdsEnabled(false)
-      params.setMessages((prev) => postUserMessage(prev))
-      params.saveToHistory(params.inputValue.trim())
-      clearInput(params)
-    },
-  }),
-  defineCommandWithArgs({
-    name: 'telemetry',
-    aliases: ['analytics'],
-    handler: (params, args) => {
-      const postUserMessage = handleTelemetryCommand(args)
-      params.setMessages((prev) => postUserMessage(prev))
-      params.saveToHistory(params.inputValue.trim())
-      clearInput(params)
-    },
-  }),
-  defineCommand({
-    name: 'help',
-    aliases: ['h', '?'],
-    handler: async (params) => {
-      const { postUserMessage } = await handleHelpCommand()
-      params.setMessages((prev) => postUserMessage(prev))
-      params.saveToHistory(params.inputValue.trim())
-      clearInput(params)
-      // FID-2026-0718-010 D3: slash-command bridges resetUiToIdle when idle.
-      resetUiToIdleAfterSlashCommand()
-    },
-  }),
-  defineCommandWithArgs({
-    name: 'goal',
-    aliases: ['g'],
-    handler: handleGoalCommand,
-  }),
-  defineCommandWithArgs({
-    name: 'loop',
-    aliases: ['repeat'],
-    handler: handleLoopCommand,
-  }),
-  defineCommand({
-    name: 'health',
-    aliases: ['status', 'check'],
-    handler: async (params) => {
-      await handleHealthCommand(params)
-      params.saveToHistory(params.inputValue.trim())
-      clearInput(params)
-      resetUiToIdleAfterSlashCommand()
-    },
-  }),
-  defineCommand({
-    name: 'diagnostics',
-    aliases: ['diag', 'processes'],
-    handler: (params) => {
-      const diagnostics = formatProcessDiagnostics(collectProcessDiagnostics())
-      params.setMessages((prev) => [...prev, getSystemMessage(diagnostics)])
-      params.saveToHistory(params.inputValue.trim())
-      clearInput(params)
-      // FID-2026-0718-010 D3: slash-command bridges resetUiToIdle when idle.
-      resetUiToIdleAfterSlashCommand()
-    },
-  }),
-  defineCommand({
-    name: 'copy',
-    aliases: ['copy-chat', 'export'],
-    handler: async (params) => {
-      await handleCopyConversationCommand(params)
-    },
-  }),
-  defineCommandWithArgs({
-    name: 'feedback',
-    aliases: ['bug', 'report'],
-    handler: (params, args) => {
-      const trimmedArgs = args.trim()
-
-      // If user provided feedback text directly, pre-populate the form
-      if (trimmedArgs) {
-        useFeedbackStore.getState().setFeedbackText(trimmedArgs)
-        useFeedbackStore.getState().setFeedbackCursor(trimmedArgs.length)
-      }
-
-      params.saveToHistory(params.inputValue.trim())
-      clearInput(params)
-      return { openFeedbackMode: true }
-    },
-  }),
-  defineCommandWithArgs({
-    name: 'bash',
-    aliases: ['!'],
-    handler: (params, args) => {
-      const trimmedArgs = args.trim()
-
-      // If user provided a command directly, execute it immediately
-      if (trimmedArgs) {
-        const commandWithBang = '!' + trimmedArgs
-        params.saveToHistory(commandWithBang)
-        clearInput(params)
-        runBashCommand(trimmedArgs)
-        return
-      }
-
-      // Otherwise enter bash mode
-      useChatStore.getState().setInputMode('bash')
-      params.saveToHistory(params.inputValue.trim())
-      clearInput(params)
-    },
-  }),
-  defineCommand({
-    name: 'login',
-    aliases: ['signin'],
-    handler: (params) => {
-      params.abortControllerRef.current?.abort()
-      params.stopStreaming()
-      params.setCanProcessQueue(false)
-
-      const { resetLoginState } = useLoginStore.getState()
-      resetLoginState()
-      params.setMessages((prev) => [
-        ...prev,
-        getUserMessage(params.inputValue.trim()),
-        getSystemMessage('Opening login screen...'),
-      ])
-      params.saveToHistory(params.inputValue.trim())
-      clearInput(params)
-      params.setUser(null)
-      params.setIsAuthenticated(false)
-    },
-  }),
-  defineCommand({
-    name: 'logout',
-    aliases: ['signout'],
-    handler: (params) => {
-      params.abortControllerRef.current?.abort()
-      params.stopStreaming()
-      params.setCanProcessQueue(false)
-
-      const { resetLoginState } = useLoginStore.getState()
-      params.logoutMutation.mutate(undefined, {
-        onSettled: () => {
-          resetLoginState()
-          params.setMessages((prev) => [
-            ...prev,
-            getSystemMessage('Logged out.'),
-          ])
-          clearInput(params)
-          setTimeout(() => {
-            params.setUser(null)
-            params.setIsAuthenticated(false)
-          }, 300)
-        },
-      })
-    },
-  }),
-  defineCommand({
-    name: 'exit',
-    aliases: ['quit', 'q'],
-    handler: () => {
-      process.kill(process.pid, 'SIGINT')
-    },
-  }),
-  defineCommandWithArgs({
-    name: 'permissions',
-    aliases: ['sandbox', 'safety'],
-    handler: (params, args) => {
-      const trimmedArgs = args.trim().toLowerCase()
-      const currentMode = useChatStore.getState().permissionMode
-      const validModes = ['safe', 'prompt', 'unsafe'] as const
-      const modeDescriptions: Record<(typeof validModes)[number], string> = {
-        safe: 'Risky tools are denied automatically.',
-        prompt:
-          'Risky tools are blocked; interactive prompts are not yet implemented, so they currently downgrade to deny.',
-        unsafe: 'Risky tools are allowed. Use with caution.',
-      }
-
-      if (!trimmedArgs) {
-        params.setMessages((prev) => [
-          ...prev,
-          getUserMessage(params.inputValue.trim()),
-          getSystemMessage(
-            `Current permission mode: **${currentMode}**\n\n${modeDescriptions[currentMode]}`,
-          ),
-        ])
-        params.saveToHistory(params.inputValue.trim())
-        clearInput(params)
-        return
-      }
-
-      if (!validModes.includes(trimmedArgs as (typeof validModes)[number])) {
-        params.setMessages((prev) => [
-          ...prev,
-          getUserMessage(params.inputValue.trim()),
-          getSystemMessage(
-            `Unknown permission mode: "${trimmedArgs}". Use "/permissions safe", "/permissions prompt", or "/permissions unsafe".`,
-          ),
-        ])
-        params.saveToHistory(params.inputValue.trim())
-        clearInput(params)
-        return
-      }
-
-      const newMode = trimmedArgs as (typeof validModes)[number]
-      useChatStore.getState().setPermissionMode(newMode)
-      savePermissionModePreference(newMode)
-      params.setMessages((prev) => [
-        ...prev,
-        getUserMessage(params.inputValue.trim()),
-        getSystemMessage(
-          `Permission mode set to **${newMode}**.\n\n${modeDescriptions[newMode]}`,
-        ),
-      ])
-      params.saveToHistory(params.inputValue.trim())
-      clearInput(params)
-    },
-  }),
-  defineCommandWithArgs({
-    name: 'rewind',
-    aliases: ['undo', 'checkpoint'],
-    handler: async (params, args) => {
-      // FID-2026-0803-004: rewind a previous turn's file state and/or
-      // conversation from the persistent per-turn checkpoints.
-      await handleRewindCommand(params, args)
-    },
-  }),
-  defineCommandWithArgs({
-    name: 'verify',
-    aliases: ['typecheck'],
-    handler: async (params, args) => {
-      const trimmedArgs = args.trim().toLowerCase()
-
-      const workspaceMap: Record<string, string> = {
-        sdk: 'sdk',
-        common: 'common',
-        'agent-runtime': 'packages/agent-runtime',
-        cli: 'cli',
-      }
-
-      const workspaces =
-        trimmedArgs === ''
-          ? Object.entries(workspaceMap)
-          : [[trimmedArgs, workspaceMap[trimmedArgs]]]
-
-      if (!workspaces.length || workspaces.some(([, dir]) => !dir)) {
-        params.setMessages((prev) => [
-          ...prev,
-          getUserMessage(params.inputValue.trim()),
-          getSystemMessage('Usage: /verify [sdk|common|agent-runtime|cli]'),
-        ])
-        params.saveToHistory(params.inputValue.trim())
-        clearInput(params)
-        return
-      }
-
-      params.saveToHistory(params.inputValue.trim())
-      clearInput(params)
-
-      const results = await Promise.all(
-        workspaces.map(async ([name, dir]) => {
-          try {
-            const [{ value }] = await runTerminalCommand({
-              command: 'bun run typecheck',
-              process_type: 'SYNC',
-              cwd: dir,
-              timeout_seconds: 120,
-            })
-            const stdout = 'stdout' in value ? value.stdout || '' : ''
-            const stderr = 'stderr' in value ? value.stderr || '' : ''
-            const exitCode = 'exitCode' in value ? (value.exitCode ?? 1) : 1
-            return { name, exitCode, stdout, stderr }
-          } catch (error) {
-            return {
-              name,
-              exitCode: 1,
-              stdout: '',
-              stderr: error instanceof Error ? error.message : String(error),
-            }
-          }
-        }),
-      )
-
-      const allPassed = results.every((r) => r.exitCode === 0)
-      const summary = results
-        .map((r) => {
-          const status = r.exitCode === 0 ? 'PASS' : 'FAIL'
-          const detail =
-            r.exitCode === 0
-              ? 'No TypeScript errors'
-              : `exit ${r.exitCode}\n${(r.stderr || r.stdout).slice(0, 300)}`
-          return `${r.name}: ${status}\n${detail}`
-        })
-        .join('\n\n')
-
-      const overall = allPassed
-        ? '✅ All typechecks passed'
-        : '❌ Some typechecks failed'
-
-      params.setMessages((prev) => [
-        ...prev,
-        getSystemMessage(`${overall}\n\n${summary}`),
-      ])
-    },
-  }),
-  defineCommandWithArgs({
-    name: 'new',
-    aliases: ['n', 'clear', 'c', 'reset'],
-    handler: (params, args) => {
-      const trimmedArgs = args.trim()
-
-      // Abort any in-flight run BEFORE clearing state and rotating the chat
-      // id: an orphaned run would keep streaming after the switch and its
-      // late checkpoints/final save would persist the old conversation's
-      // state under the new chat (or vice versa).
-      abortActiveRun()
-
-      // Reset dev override mode on new chat
-      useChatStore.getState().setDevMode(false)
-
-      // Clear the conversation and rotate to a fresh chat directory, so the
-      // next message doesn't overwrite the previous conversation's history
-      params.setMessages(() => [])
-      params.clearMessages()
-      startNewChat()
-      params.saveToHistory(params.inputValue.trim())
-      clearInput(params)
-      params.stopStreaming()
-
-      // If user provided a message, send it as the first message in the new chat
-      if (trimmedArgs) {
-        // Re-enable queue processing so the message can be sent
-        params.setCanProcessQueue(true)
-        params.sendMessage({
-          content: trimmedArgs,
-          agentMode: params.agentMode,
-        })
-        setTimeout(() => {
-          params.scrollToLatest()
-        }, 0)
-      } else {
-        // Only disable queue if we're not sending a message
-        params.setCanProcessQueue(false)
-      }
-    },
-  }),
-  defineCommand({
-    name: 'init',
-    handler: async (params) => {
-      const { postUserMessage } = handleInitializationFlowLocally()
-      const trimmed = params.inputValue.trim()
-
-      params.saveToHistory(trimmed)
-      clearInput(params)
-
-      // Check streaming/queue state
-      if (
-        params.isStreaming ||
-        params.streamMessageIdRef.current ||
-        params.isChainInProgressRef.current
-      ) {
-        const pendingAttachments = capturePendingAttachments()
-        params.addToQueue(trimmed, pendingAttachments)
-        params.setInputFocused(true)
-        params.inputRef.current?.focus()
-        return
-      }
-
-      params.sendMessage({
-        content: trimmed,
-        agentMode: params.agentMode,
-        postUserMessage,
-      })
-      setTimeout(() => {
-        params.scrollToLatest()
-      }, 0)
-    },
-  }),
-  defineCommand({
-    name: 'usage',
-    aliases: ['credits'],
-    handler: async (params) => {
-      const { postUserMessage } = await handleUsageCommand()
-      params.setMessages((prev) => postUserMessage(prev))
-      params.saveToHistory(params.inputValue.trim())
-      clearInput(params)
-    },
-  }),
-  defineCommand({
-    name: 'subscribe',
-    aliases: ['strong', 'sub', 'buy-credits'],
-    handler: (params) => {
-      safeOpen(WEBSITE_URL + '/subscribe')
-      clearInput(params)
-    },
-  }),
-  defineCommandWithArgs({
-    name: 'image',
-    aliases: ['img', 'attach'],
-    handler: async (params, args) => {
-      const trimmedArgs = args.trim()
-
-      // If user provided a path directly, process it immediately
-      if (trimmedArgs) {
-        await handleImageCommand(trimmedArgs)
-        params.saveToHistory(params.inputValue.trim())
-        clearInput(params)
-        return
-      }
-
-      // Otherwise enter image mode
-      useChatStore.getState().setInputMode('image')
-      params.saveToHistory(params.inputValue.trim())
-      clearInput(params)
-    },
-  }),
-  // Mode commands generated from AGENT_MODES (excluded in SavantFree)
-  ...(IS_SAVANT_FREE ? [] : AGENT_MODES).map((mode) =>
-    defineCommandWithArgs({
-      name: `mode:${mode.toLowerCase()}`,
-      aliases: [`model:${mode.toLowerCase()}`],
-      handler: (params, args) => {
-        const trimmedArgs = args.trim()
-
-        useChatStore.getState().setAgentMode(mode)
-        params.setMessages((prev) => [
-          ...prev,
-          getUserMessage(params.inputValue.trim()),
-          getSystemMessage(`Switched to ${mode} mode.`),
-        ])
-        params.saveToHistory(params.inputValue.trim())
-        clearInput(params)
-
-        // If user provided a message, send it in the new mode
-        if (trimmedArgs) {
-          params.setCanProcessQueue(true)
-          params.sendMessage({
-            content: trimmedArgs,
-            agentMode: mode,
-          })
-          setTimeout(() => {
-            params.scrollToLatest()
-          }, 0)
-        }
-      },
-    }),
-  ),
-  ...(IS_SAVANT_FREE
-    ? []
-    : [
-        defineCommandWithArgs({
-          name: 'model',
-          aliases: ['switch-model'],
-          handler: async (params, args) => {
-            const trimmedArgs = args.trim()
-            params.saveToHistory(params.inputValue.trim())
-            clearInput(params)
-
-            // Free-text selection always works: /model <exact-id> switches
-            // immediately, even if the live catalog is unavailable.
-            if (trimmedArgs) {
-              saveSavantCodeModelPreference(trimmedArgs)
-              useSavantFreeModelStore.getState().switchModel(trimmedArgs)
-              params.setMessages((prev) => [
-                ...prev,
-                getSystemMessage(`Model switched to: ${trimmedArgs}`),
-              ])
-              return
-            }
-
-            const currentModel = loadSavantCodeModelPreference()
-
-            // Live picker: fetch the real-time OpenRouter catalog and render a
-            // filterable list. Typing /model <id> (or re-running with a filter)
-            // selects the model. Degrades to free-text if the catalog can't load.
-            const models = await fetchGatewayModels()
-            if (models.length === 0) {
-              const message = currentModel
-                ? `Current model: ${currentModel}\n\nCouldn't load the live OpenRouter model list. Type an exact model id to switch, e.g. /model anthropic/claude-sonnet-4`
-                : "No model override set. Couldn't load the live OpenRouter model list — type an exact model id to switch, e.g. /model anthropic/claude-sonnet-4"
-              params.setMessages((prev) => [...prev, getSystemMessage(message)])
-              return
-            }
-
-            useModelPickerStore.getState().open(models)
-          },
-        }),
-        defineCommandWithArgs({
-          name: 'provider',
-          handler: (params, args) => {
-            const trimmedArgs = args.trim()
-
-            // No args: open dropdown picker
-            if (!trimmedArgs) {
-              const configured = getConfiguredProviderNames()
-              const providers = (
-                Object.entries(PROVIDER_SETUP_CONFIG) as Array<
-                  [
-                    string,
-                    (typeof PROVIDER_SETUP_CONFIG)[keyof typeof PROVIDER_SETUP_CONFIG],
-                  ]
-                >
-              ).map(([name, config]) => ({
-                name: name as (typeof configured)[number],
-                label: config.label,
-                configured: configured.includes(
-                  name as (typeof configured)[number],
-                ),
-              }))
-
-              useProviderPickerStore.getState().open(providers)
-              params.saveToHistory(params.inputValue.trim())
-              clearInput(params)
-              return
-            }
-
-            const provider = beginProviderSetup(trimmedArgs)
-            const info = provider ? getProviderSetupInfo(provider) : undefined
-
-            if (!info) {
-              params.setMessages((prev) => [
-                ...prev,
-                getUserMessage(params.inputValue.trim()),
-                getSystemMessage(
-                  `Unknown provider. Use /provider followed by one of: ${Object.keys(PROVIDER_SETUP_CONFIG).join(', ')}.`,
-                ),
-              ])
-              params.saveToHistory(params.inputValue.trim())
-              clearInput(params)
-              return
-            }
-
-            params.setInputValue({
-              text: '',
-              cursorPosition: 0,
-              lastEditDueToNav: false,
-            })
-            useChatStore.getState().setInputMode('providerSetup')
-            params.setInputFocused(true)
-            params.inputRef.current?.focus()
-            params.setMessages((prev) => [
-              ...prev,
-              getUserMessage(params.inputValue.trim()),
-              getSystemMessage(
-                `${info.label} selected. Enter your API key below. It will be masked and stored locally in credentials.json. Environment variables take precedence.`,
-              ),
-            ])
-          },
-        }),
-      ]),
-  defineCommandWithArgs({
-    name: 'publish',
-    handler: (params, args) => {
-      const trimmedArgs = args.trim()
-      params.saveToHistory(params.inputValue.trim())
-      clearInput(params)
-
-      // If user provided agent ids directly, skip to confirmation step
-      if (trimmedArgs) {
-        const agentIds = trimmedArgs.split(/\s+/).filter(Boolean)
-        return { openPublishMode: true, preSelectAgents: agentIds }
-      }
-
-      // Otherwise open selection UI
-      return { openPublishMode: true }
-    },
-  }),
-  ...(CHATGPT_OAUTH_ENABLED
-    ? [
-        defineCommand({
-          name: 'connect',
-          aliases: ['connect:chatgpt', 'chatgpt'],
-          handler: (params) => {
-            useChatStore.getState().setInputMode('connect:chatgpt')
-            params.saveToHistory(params.inputValue.trim())
-            clearInput(params)
-          },
-        }),
-      ]
-    : []),
-  defineCommand({
-    name: 'history',
-    aliases: ['chats'],
-    handler: (params) => {
-      params.saveToHistory(params.inputValue.trim())
-      clearInput(params)
-      // FID-2026-0718-010 D3: slash-command bridges resetUiToIdle when idle.
-      resetUiToIdleAfterSlashCommand()
-      return { openChatHistory: true }
-    },
-  }),
-  defineCommandWithArgs({
-    name: 'interview',
-    handler: (params, args) => {
-      const trimmedArgs = args.trim()
-
-      params.saveToHistory(params.inputValue.trim())
-      clearInput(params)
-
-      // If user provided text directly, send it immediately
-      if (trimmedArgs) {
-        params.sendMessage({
-          content: buildInterviewPrompt(trimmedArgs),
-          agentMode: params.agentMode,
-        })
-        setTimeout(() => {
-          params.scrollToLatest()
-        }, 0)
-        return
-      }
-
-      // Otherwise enter interview mode
-      useChatStore.getState().setInputMode('interview')
-    },
-  }),
-  defineCommandWithArgs({
-    name: 'plan',
-    handler: (params, args) => {
-      // /plan runs on the selected model by default, or delegates to GPT when a
-      // ChatGPT account is connected (handled in buildPlanPrompt). No gate.
-      const trimmedArgs = args.trim()
-
-      params.saveToHistory(params.inputValue.trim())
-      clearInput(params)
-
-      // If user provided plan text directly, send it immediately
-      if (trimmedArgs) {
-        params.sendMessage({
-          content: buildPlanPrompt(trimmedArgs),
-          agentMode: params.agentMode,
-        })
-        setTimeout(() => {
-          params.scrollToLatest()
-        }, 0)
-        return
-      }
-
-      // Otherwise enter plan mode
-      useChatStore.getState().setInputMode('plan')
-    },
-  }),
-  defineCommandWithArgs({
-    name: 'review',
-    handler: (params, args) => {
-      // /review runs on the selected model by default, or delegates to GPT when
-      // a ChatGPT account is connected (handled in buildReviewPrompt). No gate.
-      const trimmedArgs = args.trim()
-
-      params.saveToHistory(params.inputValue.trim())
-      clearInput(params)
-
-      // If user provided review text directly, send it immediately without showing the screen
-      if (trimmedArgs) {
-        params.sendMessage({
-          content: buildReviewPromptFromArgs(trimmedArgs),
-          agentMode: params.agentMode,
-        })
-        setTimeout(() => {
-          params.scrollToLatest()
-        }, 0)
-        return
-      }
-
-      // Otherwise open the selection UI
-      return { openReviewScreen: true }
-    },
-  }),
-  defineCommand({
-    name: 'theme:toggle',
-    handler: (params) => {
-      const { theme, setThemeName } = useThemeStore.getState()
-      const newTheme = theme.name === 'dark' ? 'light' : 'dark'
-      setThemeName(newTheme)
-      params.setMessages((prev) => [
-        ...prev,
-        getUserMessage(params.inputValue.trim()),
-        getSystemMessage(`Switched to ${newTheme} theme.`),
-      ])
-      clearInput(params)
-      // FID-2026-0718-010 D3: slash-command bridges resetUiToIdle when idle.
-      resetUiToIdleAfterSlashCommand()
-    },
-  }),
-  // /end-session (savant-free-only) — end the active session early and drop back
-  // to the model picker. The hook flips status to 'none', which unmounts
-  // <Chat> and mounts <SavantFreeLandingScreen>, where the user picks a model
-  // and hits Enter to start a new session.
-  defineCommand({
-    name: 'end-session',
-    aliases: ['model'],
-    handler: (params) => {
-      params.setMessages((prev) => [
-        ...prev,
-        getUserMessage(params.inputValue.trim()),
-        getSystemMessage(END_SESSION_MESSAGE),
-      ])
-      params.saveToHistory(params.inputValue.trim())
-      clearInput(params)
-      returnToSavantFreeLanding({ resetChat: true }).catch(() => {
-        // The hook surfaces poll errors via the session store; nothing to do
-        // here beyond letting the chat history reflect the attempt.
-      })
-    },
-  }),
-]
-
-// Export the removal sets for the gating-parity test (FID-007 V4).
-export const SAVANT_FREE_REMOVED_COMMAND_NAMES = SAVANT_FREE_REMOVED_COMMANDS
-export const SAVANT_FREE_ONLY_COMMAND_NAMES = SAVANT_FREE_ONLY_COMMANDS
-
-// FID-007 V4: pure gating filter (testable in either build flavor). The
-// free/paid split must stay in lockstep with data/slash-commands.ts — the
-// registry-gating test asserts parity between the two files.
-export function filterCommandsForBuild(
-  commands: CommandDefinition[],
-  isFree: boolean,
-): CommandDefinition[] {
-  return isFree
-    ? commands.filter((cmd) => !SAVANT_FREE_REMOVED_COMMANDS.has(cmd.name))
-    : commands.filter((cmd) => !SAVANT_FREE_ONLY_COMMANDS.has(cmd.name))
-}
-
-export const COMMAND_REGISTRY: CommandDefinition[] = filterCommandsForBuild(
-  ALL_COMMANDS,
-  IS_SAVANT_FREE,
-)
-
-// Exported for the gating-parity test (FID-007 V4).
-export const ALL_COMMAND_DEFINITIONS: CommandDefinition[] = ALL_COMMANDS
-
-// Secret dev override command — hoisted so findCommand returns a stable
-// identity (FID-007 D2). Not in COMMAND_REGISTRY (invisible to /help +
-// autocomplete).
-const DEV_COMMAND_DEFINITION: CommandDefinition = defineCommandWithArgs({
-  name: 'dev',
-  handler: (params, args) => {
-    const trimmedArgs = args.trim().toLowerCase()
-    const devModeActive = useChatStore.getState().devMode
-
-    // /dev off — deactivate
-    if (trimmedArgs === 'off') {
-      if (devModeActive) {
-        useChatStore.getState().setDevMode(false)
-        params.setMessages((prev) => [
-          ...prev,
-          getSystemMessage('Dev override deactivated.'),
-        ])
-      } else {
-        params.setMessages((prev) => [
-          ...prev,
-          getSystemMessage('Dev override is already off.'),
-        ])
-      }
-      params.saveToHistory(params.inputValue.trim())
-      clearInput(params)
-      return
-    }
-
-    // /dev on — activate (no passphrase required)
-    if (trimmedArgs === 'on' || trimmedArgs === '') {
-      if (devModeActive) {
-        params.setMessages((prev) => [
-          ...prev,
-          getSystemMessage('Dev override is already active.'),
-        ])
-      } else {
-        useChatStore.getState().setDevMode(true)
-        params.setMessages((prev) => [
-          ...prev,
-          getSystemMessage('Dev override activated.'),
-        ])
-      }
-      params.saveToHistory(params.inputValue.trim())
-      clearInput(params)
-      return
-    }
-
-    // Unknown /dev subcommand
-    params.setMessages((prev) => [
-      ...prev,
-      getUserMessage(params.inputValue.trim()),
-      getSystemMessage(
-        `Unknown /dev subcommand: ${trimmedArgs}. Use "/dev on" or "/dev off".`,
-      ),
-    ])
-    params.saveToHistory(params.inputValue.trim())
-    clearInput(params)
-  },
-})
-
-export function findCommand(cmd: string): CommandDefinition | undefined {
-  const lowerCmd = cmd.toLowerCase()
-
-  // Secret dev override command — not in COMMAND_REGISTRY (invisible to /help + autocomplete)
-  if (lowerCmd === 'dev') {
-    return DEV_COMMAND_DEFINITION
-  }
-
-  // First check the static command registry
-  const staticCommand = COMMAND_REGISTRY.find(
-    (def) => def.name === lowerCmd || def.aliases.includes(lowerCmd),
-  )
-  if (staticCommand) {
-    return staticCommand
-  }
-
-  // Check if this is a skill command (prefixed with "skill:")
-  if (lowerCmd.startsWith('skill:')) {
-    const skillName = lowerCmd.slice('skill:'.length)
-    const skill = getSkillByName(skillName)
-    if (skill) {
-      return createSkillCommand(skill.name)
-    }
-  }
-
-  return undefined
-}
-
-/**
- * Creates a dynamic command definition for a skill.
- * When invoked, the skill's content is sent to the agent.
- */
-function createSkillCommand(skillName: string): CommandDefinition {
-  return defineCommandWithArgs({
-    name: skillName,
-    handler: (params, args) => {
-      const skill = getSkillByName(skillName)
-      if (!skill) {
-        params.setMessages((prev) => [
-          ...prev,
-          getUserMessage(params.inputValue.trim()),
-          getSystemMessage(`Skill not found: ${skillName}`),
-        ])
-        params.saveToHistory(params.inputValue.trim())
-        params.setInputValue({
-          text: '',
-          cursorPosition: 0,
-          lastEditDueToNav: false,
-        })
-        return
-      }
-
-      const trimmed = params.inputValue.trim()
-      params.saveToHistory(trimmed)
-      params.setInputValue({
-        text: '',
-        cursorPosition: 0,
-        lastEditDueToNav: false,
-      })
-
-      // Build the message content with skill context and optional user args
-      const skillContext = `<skill name="${skill.name}">
-${skill.content}
-</skill>`
-
-      const userPrompt =
-        `I invoke the following skill:\n\n${skillContext}\n\n` +
-        (args.trim() ? `User request: ${args.trim()}` : '')
-
-      // Check streaming/queue state
-      if (
-        params.isStreaming ||
-        params.streamMessageIdRef.current ||
-        params.isChainInProgressRef.current
-      ) {
-        const pendingAttachments = capturePendingAttachments()
-        params.addToQueue(userPrompt, pendingAttachments)
-        params.setInputFocused(true)
-        params.inputRef.current?.focus()
-        return
-      }
-
-      params.sendMessage({
-        content: userPrompt,
-        agentMode: params.agentMode,
-      })
-      setTimeout(() => {
-        params.scrollToLatest()
-      }, 0)
-    },
-  })
-}