Default freebuff to DeepSeek V4 Pro, switch lite to Kimi

- Freebuff picker now offers DeepSeek (default, smartest, with "Collects data
  for training" warning), Kimi K2.6, and MiniMax. Both Kimi and DeepSeek run
  24/7 with 5/18h rate limits and 1000-slot instant-admit capacity.
- Codebuff Lite (paid) defaults to Kimi instead of DeepSeek to avoid silently
  routing user prompts through a model whose provider trains on them.
- Generalised the gemini-thinker session bypass from Kimi-only to any smart
  parent model, with `canFreebuffModelSpawnGeminiThinker` as the helper.
- Editor variant table replaces the chained ternary; only Opus retains
  <think>-tag scaffolding.
- Disabled INCLUDE_REASONING_IN_MESSAGE_HISTORY pending broader testing; the
  new stream-parser-reasoning tests skip while it's off.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: jahooma

agents/__tests__/editor.test.ts

@@ -70,6 +70,11 @@ describe('editor agent', () => {
       expect(kimiEditor.model).toBe('moonshotai/kimi-k2.6')
     })
 
+    test('creates deepseek editor', () => {
+      const deepseekEditor = createCodeEditor({ model: 'deepseek' })
+      expect(deepseekEditor.model).toBe('deepseek/deepseek-v4-pro')
+    })
+
     test('creates minimax editor', () => {
       const minimaxEditor = createCodeEditor({ model: 'minimax' })
       expect(minimaxEditor.model).toBe('minimax/minimax-m2.7')
@@ -93,6 +98,12 @@ describe('editor agent', () => {
       expect(kimiEditor.instructionsPrompt).not.toContain('</think>')
     })
 
+    test('deepseek editor does not include think tags in instructions', () => {
+      const deepseekEditor = createCodeEditor({ model: 'deepseek' })
+      expect(deepseekEditor.instructionsPrompt).not.toContain('<think>')
+      expect(deepseekEditor.instructionsPrompt).not.toContain('</think>')
+    })
+
     test('minimax editor does not include think tags in instructions', () => {
       const minimaxEditor = createCodeEditor({ model: 'minimax' })
       expect(minimaxEditor.instructionsPrompt).not.toContain('<think>')

agents/base2/base2.ts

@@ -1,5 +1,4 @@
 import { buildArray } from '@codebuff/common/util/array'
-import { FREEBUFF_KIMI_MODEL_ID } from '@codebuff/common/constants/freebuff-models'
 import {
   FREEBUFF_GEMINI_THINKER_AGENT_ID,
   FREEBUFF_GEMINI_THINKER_INSTRUCTIONS_PROMPT,
@@ -36,10 +35,23 @@ export function createBase2(
   const isFree = mode === 'free' || mode === 'lite'
 
   const isSonnet = false
+  // Lite (paid Codebuff) defaults to Kimi: no data-retention surface in the
+  // CLI today, so we don't want to silently route Codebuff prompts through a
+  // model whose provider trains on user data. Free (freebuff) defaults to
+  // DeepSeek and surfaces the data-collection caveat in the picker; the CLI
+  // overrides the model anyway based on the user's freebuff selection.
   const model =
     modelOverride ??
-    (isFree ? 'moonshotai/kimi-k2.6' : 'anthropic/claude-opus-4.7')
-  const hasFreeGeminiThinker = isFree && model === FREEBUFF_KIMI_MODEL_ID
+    (mode === 'lite'
+      ? 'moonshotai/kimi-k2.6'
+      : mode === 'free'
+        ? 'deepseek/deepseek-v4-pro'
+        : 'anthropic/claude-opus-4.7')
+  // Bundled free-mode definitions ship with the gemini-thinker spawnable +
+  // prompts; the CLI strips them at runtime if the user picks a fast model
+  // that doesn't benefit (e.g. MiniMax). Smart freebuff models (Kimi,
+  // DeepSeek) keep it so they can offload deeper reasoning.
+  const hasFreeGeminiThinker = isFree
   const defaultProviderOptions = isFree
     ? {
         data_collection: 'deny' as const,

agents/editor/editor.ts

@@ -2,22 +2,37 @@ import { publisher } from '../constants'
 
 import type { AgentDefinition } from '../types/agent-definition'
 
+type CodeEditorVariant =
+  | 'gpt-5'
+  | 'opus'
+  | 'glm'
+  | 'kimi'
+  | 'deepseek'
+  | 'minimax'
+
+const EDITOR_MODEL_BY_VARIANT: Record<CodeEditorVariant, string> = {
+  'gpt-5': 'openai/gpt-5.1',
+  opus: 'anthropic/claude-opus-4.7',
+  glm: 'z-ai/glm-5.1',
+  kimi: 'moonshotai/kimi-k2.6',
+  deepseek: 'deepseek/deepseek-v4-pro',
+  minimax: 'minimax/minimax-m2.7',
+}
+
+// Only Opus gets <think>-tag scaffolding in its instructions; the other
+// variants either have native reasoning (deepseek) or are non-reasoning
+// models where the extra prose just bloats the prompt without helping.
+const EDITOR_VARIANTS_WITH_THINK_TAGS: ReadonlySet<CodeEditorVariant> = new Set(
+  ['opus'],
+)
+
 export const createCodeEditor = (options: {
-  model: 'gpt-5' | 'opus' | 'glm' | 'kimi' | 'minimax'
+  model: CodeEditorVariant
 }): Omit<AgentDefinition, 'id'> => {
   const { model } = options
   return {
     publisher,
-    model:
-      options.model === 'gpt-5'
-        ? 'openai/gpt-5.1'
-        : options.model === 'minimax'
-          ? 'minimax/minimax-m2.7'
-          : options.model === 'kimi'
-            ? 'moonshotai/kimi-k2.6'
-            : options.model === 'glm'
-              ? 'z-ai/glm-5.1'
-              : 'anthropic/claude-opus-4.7',
+    model: EDITOR_MODEL_BY_VARIANT[options.model],
     ...(options.model === 'opus' && {
       providerOptions: {
         only: ['amazon-bedrock'],
@@ -69,12 +84,8 @@ OR for new files or major rewrites:
 </codebuff_tool_call>
 
 ${
-  model === 'gpt-5' ||
-  model === 'glm' ||
-  model === 'kimi' ||
-  model === 'minimax'
-    ? ''
-    : `Before you start writing your implementation, you should use <think> tags to think about the best way to implement the changes.
+  EDITOR_VARIANTS_WITH_THINK_TAGS.has(model)
+    ? `Before you start writing your implementation, you should use <think> tags to think about the best way to implement the changes.
 
 You can also use <think> tags interspersed between tool calls to think about the best way to implement the changes.
 
@@ -101,6 +112,7 @@ You can also use <think> tags interspersed between tool calls to think about the
 </codebuff_tool_call>
 
 </example>`
+    : ''
 }
 
 Your implementation should:

cli/src/__tests__/integration/local-agents.test.ts

@@ -10,6 +10,7 @@ import {
   FREEBUFF_GEMINI_THINKER_SYSTEM_INSTRUCTION,
 } from '@codebuff/common/constants/freebuff-gemini-thinker'
 import {
+  FREEBUFF_DEEPSEEK_V4_PRO_MODEL_ID,
   FREEBUFF_KIMI_MODEL_ID,
   FREEBUFF_MINIMAX_MODEL_ID,
 } from '@codebuff/common/constants/freebuff-models'
@@ -77,6 +78,26 @@ describe('configureFreebuffBaseAgentForModel', () => {
     expect(definition.stepPrompt).toContain(FREEBUFF_GEMINI_THINKER_STEP_PROMPT)
   })
 
+  test('keeps the Gemini thinker and prompt guidance for DeepSeek', () => {
+    const definition = makeBase2Free()
+
+    configureFreebuffBaseAgentForModel(
+      definition,
+      FREEBUFF_DEEPSEEK_V4_PRO_MODEL_ID,
+    )
+
+    expect(definition.spawnableAgents).toContain(
+      FREEBUFF_GEMINI_THINKER_AGENT_ID,
+    )
+    expect(definition.systemPrompt).toContain(
+      FREEBUFF_GEMINI_THINKER_SYSTEM_INSTRUCTION,
+    )
+    expect(definition.instructionsPrompt).toContain(
+      FREEBUFF_GEMINI_THINKER_INSTRUCTIONS_PROMPT,
+    )
+    expect(definition.stepPrompt).toContain(FREEBUFF_GEMINI_THINKER_STEP_PROMPT)
+  })
+
   test('removes only exact Gemini thinker prompt guidance for MiniMax', () => {
     const definition = makeBase2Free()
     definition.systemPrompt +=

cli/src/components/freebuff-model-selector.tsx

@@ -4,8 +4,8 @@ import React, { useCallback, useEffect, useMemo, useState } from 'react'
 
 import { Button } from './button'
 import {
+  DEFAULT_FREEBUFF_MODEL_ID,
   FALLBACK_FREEBUFF_MODEL_ID,
-  FREEBUFF_KIMI_MODEL_ID,
   FREEBUFF_MODELS,
   getFreebuffDeploymentAvailabilityLabel,
   isFreebuffModelAvailable,
@@ -19,11 +19,16 @@ import { useTerminalDimensions } from '../hooks/use-terminal-dimensions'
 import { useTheme } from '../hooks/use-theme'
 import { nextFreebuffModelId } from '../utils/freebuff-model-navigation'
 
+import type { FreebuffModelOption } from '@codebuff/common/constants/freebuff-models'
 import type { KeyEvent } from '@opentui/core'
 
-const FREEBUFF_MODEL_SELECTOR_MODELS = [
-  ...FREEBUFF_MODELS.filter((model) => model.id === FREEBUFF_KIMI_MODEL_ID),
-  ...FREEBUFF_MODELS.filter((model) => model.id !== FREEBUFF_KIMI_MODEL_ID),
+// Widen the readonly tuple from FREEBUFF_MODELS to FreebuffModelOption[] so
+// the selector can branch on optional fields (e.g. `warning`) and on
+// availability values that aren't present in today's set but might be added
+// later, without TS narrowing the literal types away.
+const FREEBUFF_MODEL_SELECTOR_MODELS: readonly FreebuffModelOption[] = [
+  ...FREEBUFF_MODELS.filter((model) => model.id === DEFAULT_FREEBUFF_MODEL_ID),
+  ...FREEBUFF_MODELS.filter((model) => model.id !== DEFAULT_FREEBUFF_MODEL_ID),
 ]
 
 /**
@@ -69,7 +74,7 @@ export const FreebuffModelSelector: React.FC = () => {
     // unavailable (e.g. deployment hours close while the picker is open),
     // swap to the always-available fallback so Enter doesn't POST a model
     // the server will immediately reject. In-memory only — the user's saved
-    // preference (e.g. Kimi) is preserved for the next launch.
+    // preference (e.g. Kimi or DeepSeek) is preserved for the next launch.
     if (
       (session?.status === 'none' || !session) &&
       !isFreebuffModelAvailable(selectedModel, new Date(now))
@@ -119,7 +124,7 @@ export const FreebuffModelSelector: React.FC = () => {
 
   // Decide row vs column layout based on whether the buttons actually fit
   // side-by-side. Each button's inner text is
-  // "● {displayName} · {tagline} · {hours}  {hint}",
+  // "● {displayName} · {tagline} · {hours/warning}  {hint}",
   // plus 2 cols of border and 2 cols of padding. Buttons are separated by a
   // gap of 2. If the total exceeds the terminal width, stack vertically.
   const stackVertically = useMemo(() => {
@@ -134,6 +139,7 @@ export const FreebuffModelSelector: React.FC = () => {
         (model.availability === 'deployment_hours'
           ? 3 + deploymentAvailabilityLabel.length
           : 0) +
+        (model.warning ? 3 + model.warning.length : 0) +
         2 /* "  " */ +
         hintWidth
       return sum + inner + BUTTON_CHROME + (idx > 0 ? GAP : 0)
@@ -302,6 +308,9 @@ export const FreebuffModelSelector: React.FC = () => {
                 {model.availability === 'deployment_hours' && (
                   <span fg={theme.muted}> · {deploymentAvailabilityLabel}</span>
                 )}
+                {model.warning && (
+                  <span fg={theme.secondary}> · {model.warning}</span>
+                )}
                 <span fg={hintColor}> {hint.padEnd(hintWidth)}</span>
               </text>
             </Button>

cli/src/components/waiting-room-screen.tsx

@@ -260,9 +260,9 @@ export const WaitingRoomScreen: React.FC<WaitingRoomScreenProps> = ({
                   <span>Elapsed </span>
                   {formatElapsed(elapsedMs)}
                 </text>
-                {/* Per-model session quota (e.g. Kimi K2.6 caps at 5/12h). Only
-                    rendered for rate-limited models so the Minimax queue stays
-                    clutter-free. */}
+                {/* Per-model session quota (e.g. DeepSeek V4 Pro caps at 5/12h).
+                    Only rendered for rate-limited models so the Minimax queue
+                    stays clutter-free. */}
                 {session.rateLimit && (
                   <text style={{ fg: theme.muted, alignSelf: 'flex-start' }}>
                     <span>Sessions </span>
@@ -343,8 +343,8 @@ export const WaitingRoomScreen: React.FC<WaitingRoomScreenProps> = ({
             </>
           )}
 
-          {/* Per-model session quota exhausted (e.g. 5+ Kimi sessions in the
-              last 12h). Terminal for this run — the user can exit and come
+          {/* Per-model session quota exhausted (e.g. 5+ DeepSeek sessions in
+              the last 12h). Terminal for this run — the user can exit and come
               back once the oldest session in the window rolls off. */}
           {session?.status === 'rate_limited' && (
             <>

cli/src/hooks/use-freebuff-session.ts

@@ -104,7 +104,7 @@ async function callSession(
       return body
     }
   }
-  // 429 from POST is the per-model session-quota reject (e.g. too many Kimi
+  // 429 from POST is the per-model session-quota reject (e.g. too many DeepSeek
   // sessions in the last 12h). Terminal for the current poll — the CLI shows
   // a screen explaining the limit and when the user can try again. The 429
   // status (rather than 200) keeps older CLIs in their error path so they
@@ -442,10 +442,10 @@ export function useFreebuffSession(): UseFreebuffSessionResult {
         }
         if (next.status === 'model_unavailable') {
           // Server says the requested model isn't available right now (e.g.
-          // Kimi outside deployment hours). Flip to the always-available
-          // fallback for this run. In-memory only — `setSelectedModel`
-          // doesn't persist, so the user's saved preference (e.g. Kimi)
-          // is preserved for their next launch during deployment hours.
+          // legacy GLM 5.1 outside deployment hours). Flip to the
+          // always-available fallback for this run. In-memory only —
+          // `setSelectedModel` doesn't persist, so the user's saved preference
+          // is preserved for their next launch.
           useFreebuffModelStore
             .getState()
             .setSelectedModel(FALLBACK_FREEBUFF_MODEL_ID)

cli/src/utils/local-agent-registry.ts

@@ -16,7 +16,7 @@ import {
   FREEBUFF_GEMINI_THINKER_PROMPT_LINES,
 } from '@codebuff/common/constants/freebuff-gemini-thinker'
 import {
-  FREEBUFF_KIMI_MODEL_ID,
+  canFreebuffModelSpawnGeminiThinker,
   FREEBUFF_MODELS,
 } from '@codebuff/common/constants/freebuff-models'
 
@@ -57,24 +57,23 @@ function stripFreebuffGeminiThinkerPrompt(prompt: string): string {
     .join('\n')
 }
 
+/** The bundled `base2-free` ships with the gemini-thinker spawnable + prompts
+ *  so the smart freebuff models (Kimi, DeepSeek) can offload deeper reasoning.
+ *  When the user picks a model that doesn't support gemini-thinker (e.g.
+ *  MiniMax — fastest tier, extra round-trip would defeat that), strip the
+ *  spawnable and the inlined prompt guidance so the agent doesn't try to call
+ *  a tool we just removed. */
 export function configureFreebuffBaseAgentForModel(
   def: ConfigurableFreebuffBaseAgent,
   selectedModel: string,
 ): void {
   if (def.id !== 'base2-free') return
+  if (canFreebuffModelSpawnGeminiThinker(selectedModel)) return
 
-  const hasGeminiThinker = selectedModel === FREEBUFF_KIMI_MODEL_ID
   const spawnableAgents = def.spawnableAgents ?? []
-
-  def.spawnableAgents = hasGeminiThinker
-    ? Array.from(
-        new Set([...spawnableAgents, FREEBUFF_GEMINI_THINKER_AGENT_ID]),
-      )
-    : spawnableAgents.filter(
-        (agentId) => agentId !== FREEBUFF_GEMINI_THINKER_AGENT_ID,
-      )
-
-  if (hasGeminiThinker) return
+  def.spawnableAgents = spawnableAgents.filter(
+    (agentId) => agentId !== FREEBUFF_GEMINI_THINKER_AGENT_ID,
+  )
 
   for (const key of [
     'systemPrompt',

common/src/__tests__/freebuff-models.test.ts

@@ -1,9 +1,12 @@
 import { describe, expect, test } from 'bun:test'
 
 import {
+  canFreebuffModelSpawnGeminiThinker,
   DEFAULT_FREEBUFF_MODEL_ID,
+  FREEBUFF_DEEPSEEK_V4_PRO_MODEL_ID,
   FREEBUFF_GLM_MODEL_ID,
   FREEBUFF_KIMI_MODEL_ID,
+  FREEBUFF_MINIMAX_MODEL_ID,
   FREEBUFF_MODELS,
   SUPPORTED_FREEBUFF_MODELS,
   getFreebuffDeploymentAvailabilityLabel,
@@ -13,8 +16,25 @@ import {
 } from '../constants/freebuff-models'
 
 describe('freebuff model availability', () => {
-  test('defaults to Kimi K2.6', () => {
-    expect(DEFAULT_FREEBUFF_MODEL_ID).toBe(FREEBUFF_KIMI_MODEL_ID)
+  test('defaults to DeepSeek V4 Pro (the smartest free model)', () => {
+    expect(DEFAULT_FREEBUFF_MODEL_ID).toBe(FREEBUFF_DEEPSEEK_V4_PRO_MODEL_ID)
+  })
+
+  test('DeepSeek carries the data-collection warning so users see it before picking', () => {
+    const deepseek = FREEBUFF_MODELS.find(
+      (m) => m.id === FREEBUFF_DEEPSEEK_V4_PRO_MODEL_ID,
+    )
+    expect(deepseek?.warning).toBe('Collects data for training')
+  })
+
+  test('only smart freebuff models can spawn the gemini-thinker subagent', () => {
+    expect(canFreebuffModelSpawnGeminiThinker(FREEBUFF_KIMI_MODEL_ID)).toBe(true)
+    expect(
+      canFreebuffModelSpawnGeminiThinker(FREEBUFF_DEEPSEEK_V4_PRO_MODEL_ID),
+    ).toBe(true)
+    expect(canFreebuffModelSpawnGeminiThinker(FREEBUFF_MINIMAX_MODEL_ID)).toBe(
+      false,
+    )
   })
 
   test('supports GLM 5.1 as a legacy server-side model without selecting it for new clients', () => {

common/src/constants/free-agents.ts

@@ -63,7 +63,7 @@ export const FREE_MODE_AGENT_MODELS: Record<string, Set<string>> = {
   // Code reviewer for free mode
   'code-reviewer-lite': new Set(FREEBUFF_ALLOWED_MODEL_IDS),
 
-  // Kimi freebuff root may spawn Gemini Pro for deeper thinking.
+  // Legacy: kept for the standalone gemini thinker agent if invoked directly.
   [FREEBUFF_GEMINI_THINKER_AGENT_ID]: new Set([FREEBUFF_GEMINI_PRO_MODEL_ID]),
 }