@geminilight/mindos 0.5.12 → 0.5.13

package/app/app/api/ask/route.ts

@@ -4,7 +4,8 @@ import { NextRequest, NextResponse } from 'next/server';
 import fs from 'fs';
 import path from 'path';
 import { getFileContent, getMindRoot } from '@/lib/fs';
-import { getModel, knowledgeBaseTools, truncate, AGENT_SYSTEM_PROMPT } from '@/lib/agent';
+import { getModel, knowledgeBaseTools, truncate, AGENT_SYSTEM_PROMPT, estimateTokens, estimateStringTokens, getContextLimit, needsCompact, truncateToolOutputs, compactMessages, hardPrune } from '@/lib/agent';
+import { effectiveAiConfig, readSettings } from '@/lib/settings';
 import type { Message as FrontendMessage, ToolCallPart as FrontendToolCallPart } from '@/lib/types';
 
 /**
@@ -62,6 +63,7 @@ function convertToModelMessages(messages: FrontendMessage[]): ModelMessage[] {
           completedToolCalls.push(part);
         }
       }
+      // 'reasoning' parts are display-only; not sent back to model
     }
 
     if (assistantContent.length > 0) {
@@ -124,8 +126,19 @@ export async function POST(req: NextRequest) {
     return NextResponse.json({ error: 'Invalid JSON body' }, { status: 400 });
   }
 
-  const { messages, currentFile, attachedFiles, uploadedFiles, maxSteps } = body;
-  const stepLimit = Number.isFinite(maxSteps) ? Math.min(30, Math.max(1, Number(maxSteps))) : 20;
+  const { messages, currentFile, attachedFiles, uploadedFiles } = body;
+
+  // Read agent config from settings
+  // NOTE: readSettings() is also called inside getModel() → effectiveAiConfig().
+  // Acceptable duplication — both are sync fs reads with identical results.
+  const serverSettings = readSettings();
+  const agentConfig = serverSettings.agent ?? {};
+  const stepLimit = Number.isFinite(body.maxSteps)
+    ? Math.min(30, Math.max(1, Number(body.maxSteps)))
+    : Math.min(30, Math.max(1, agentConfig.maxSteps ?? 20));
+  const enableThinking = agentConfig.enableThinking ?? false;
+  const thinkingBudget = agentConfig.thinkingBudget ?? 5000;
+  const contextStrategy = agentConfig.contextStrategy ?? 'auto';
 
   // Auto-load skill + bootstrap context for each request.
   const skillPath = path.resolve(process.cwd(), 'data/skills/mindos/SKILL.md');
@@ -143,19 +156,21 @@ export async function POST(req: NextRequest) {
     target_config_md: targetDir ? readKnowledgeFile(`${targetDir}/CONFIG.md`) : null,
   };
 
-  const initStatus = [
-    `skill.mindos: ${skill.ok ? 'ok' : `failed (${skill.error})`} [${skillPath}]`,
-    `bootstrap.instruction: ${bootstrap.instruction.ok ? 'ok' : `failed (${bootstrap.instruction.error})`}`,
-    `bootstrap.index: ${bootstrap.index.ok ? 'ok' : `failed (${bootstrap.index.error})`}`,
-    `bootstrap.config_json: ${bootstrap.config_json.ok ? 'ok' : `failed (${bootstrap.config_json.error})`}`,
-    `bootstrap.config_md: ${bootstrap.config_md.ok ? 'ok' : `failed (${bootstrap.config_md.error})`}`,
-    `bootstrap.target_dir: ${targetDir ?? '(none)'}`,
-    `bootstrap.target_readme: ${bootstrap.target_readme ? (bootstrap.target_readme.ok ? 'ok' : `failed (${bootstrap.target_readme.error})`) : 'skipped'}`,
-    `bootstrap.target_instruction: ${bootstrap.target_instruction ? (bootstrap.target_instruction.ok ? 'ok' : `failed (${bootstrap.target_instruction.error})`) : 'skipped'}`,
-    `bootstrap.target_config_json: ${bootstrap.target_config_json ? (bootstrap.target_config_json.ok ? 'ok' : `failed (${bootstrap.target_config_json.error})`) : 'skipped'}`,
-    `bootstrap.target_config_md: ${bootstrap.target_config_md ? (bootstrap.target_config_md.ok ? 'ok' : `failed (${bootstrap.target_config_md.error})`) : 'skipped'}`,
-    `bootstrap.mind_root: ${getMindRoot()}`,
-  ].join('\n');
+  // Only report failures — when everything loads fine, a single summary line suffices.
+  const initFailures: string[] = [];
+  if (!skill.ok) initFailures.push(`skill.mindos: failed (${skill.error})`);
+  if (!bootstrap.instruction.ok) initFailures.push(`bootstrap.instruction: failed (${bootstrap.instruction.error})`);
+  if (!bootstrap.index.ok) initFailures.push(`bootstrap.index: failed (${bootstrap.index.error})`);
+  if (!bootstrap.config_json.ok) initFailures.push(`bootstrap.config_json: failed (${bootstrap.config_json.error})`);
+  if (!bootstrap.config_md.ok) initFailures.push(`bootstrap.config_md: failed (${bootstrap.config_md.error})`);
+  if (bootstrap.target_readme && !bootstrap.target_readme.ok) initFailures.push(`bootstrap.target_readme: failed (${bootstrap.target_readme.error})`);
+  if (bootstrap.target_instruction && !bootstrap.target_instruction.ok) initFailures.push(`bootstrap.target_instruction: failed (${bootstrap.target_instruction.error})`);
+  if (bootstrap.target_config_json && !bootstrap.target_config_json.ok) initFailures.push(`bootstrap.target_config_json: failed (${bootstrap.target_config_json.error})`);
+  if (bootstrap.target_config_md && !bootstrap.target_config_md.ok) initFailures.push(`bootstrap.target_config_md: failed (${bootstrap.target_config_md.error})`);
+
+  const initStatus = initFailures.length === 0
+    ? `All initialization contexts loaded successfully. mind_root=${getMindRoot()}${targetDir ? `, target_dir=${targetDir}` : ''}`
+    : `Initialization issues:\n${initFailures.join('\n')}\nmind_root=${getMindRoot()}${targetDir ? `, target_dir=${targetDir}` : ''}`;
 
   const initContextBlocks: string[] = [];
   if (skill.ok) initContextBlocks.push(`## mindos_skill_md\n\n${skill.content}`);
@@ -227,7 +242,34 @@ export async function POST(req: NextRequest) {
 
   try {
     const model = getModel();
-    const modelMessages = convertToModelMessages(messages);
+    const cfg = effectiveAiConfig();
+    const modelName = cfg.provider === 'openai' ? cfg.openaiModel : cfg.anthropicModel;
+    let modelMessages = convertToModelMessages(messages);
+
+    // Phase 3: Context management pipeline
+    // 1. Truncate tool outputs in historical messages
+    modelMessages = truncateToolOutputs(modelMessages);
+
+    const preTokens = estimateTokens(modelMessages);
+    const sysTokens = estimateStringTokens(systemPrompt);
+    const ctxLimit = getContextLimit(modelName);
+    console.log(`[ask] Context: ~${preTokens + sysTokens} tokens (messages=${preTokens}, system=${sysTokens}), limit=${ctxLimit}`);
+
+    // 2. Compact if >70% context limit (skip if user disabled)
+    if (contextStrategy === 'auto' && needsCompact(modelMessages, systemPrompt, modelName)) {
+      console.log('[ask] Context >70% limit, compacting...');
+      const result = await compactMessages(modelMessages, model);
+      modelMessages = result.messages;
+      if (result.compacted) {
+        const postTokens = estimateTokens(modelMessages);
+        console.log(`[ask] After compact: ~${postTokens + sysTokens} tokens`);
+      } else {
+        console.log('[ask] Compact skipped (too few messages), hard prune will handle overflow if needed');
+      }
+    }
+
+    // 3. Hard prune if still >90% context limit
+    modelMessages = hardPrune(modelMessages, systemPrompt, modelName);
 
     // Phase 2: Step monitoring + loop detection
     const stepHistory: Array<{ tool: string; input: string }> = [];
@@ -240,6 +282,13 @@ export async function POST(req: NextRequest) {
       messages: modelMessages,
       tools: knowledgeBaseTools,
       stopWhen: stepCountIs(stepLimit),
+      ...(enableThinking && cfg.provider === 'anthropic' ? {
+        providerOptions: {
+          anthropic: {
+            thinking: { type: 'enabled', budgetTokens: thinkingBudget },
+          },
+        },
+      } : {}),
 
       onStepFinish: ({ toolCalls, usage }) => {
         if (toolCalls) {

package/app/app/api/mcp/status/route.ts

@@ -6,28 +6,23 @@ export async function GET() {
   try {
     const settings = readSettings();
     const port = settings.mcpPort ?? 8781;
-    const endpoint = `http://127.0.0.1:${port}/mcp`;
+    const baseUrl = `http://127.0.0.1:${port}`;
+    const endpoint = `${baseUrl}/mcp`;
     const authConfigured = !!settings.authToken;
 
-    // Check if MCP server is running
     let running = false;
-    let toolCount = 0;
+
     try {
+      // Use the health endpoint — avoids MCP handshake complexity
+      const healthUrl = `${baseUrl}/api/health`;
       const controller = new AbortController();
       const timeout = setTimeout(() => controller.abort(), 2000);
-      const res = await fetch(endpoint, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'tools/list', params: {} }),
-        signal: controller.signal,
-      });
+      const res = await fetch(healthUrl, { signal: controller.signal, cache: 'no-store' });
       clearTimeout(timeout);
+
       if (res.ok) {
-        running = true;
-        try {
-          const data = await res.json();
-          if (data?.result?.tools) toolCount = data.result.tools.length;
-        } catch { /* non-JSON response — still running */ }
+        const data = await res.json() as { ok?: boolean; service?: string };
+        running = data.ok === true && data.service === 'mindos';
       }
     } catch {
       // Connection refused or timeout — not running
@@ -38,7 +33,7 @@ export async function GET() {
       transport: 'http',
       endpoint,
       port,
-      toolCount,
+      toolCount: running ? 20 : 0,
       authConfigured,
     });
   } catch (err) {

package/app/app/api/settings/route.ts

@@ -49,6 +49,7 @@ export async function GET() {
     webPassword: settings.webPassword ? '***set***' : '',
     authToken: maskToken(settings.authToken),
     mcpPort: settings.mcpPort ?? 8781,
+    agent: settings.agent ?? {},
     envOverrides: {
       AI_PROVIDER:       !!process.env.AI_PROVIDER,
       ANTHROPIC_API_KEY: !!process.env.ANTHROPIC_API_KEY,
@@ -110,6 +111,7 @@ export async function POST(req: NextRequest) {
         },
       },
       mindRoot: body.mindRoot ?? current.mindRoot,
+      agent: body.agent ?? current.agent,
       webPassword: resolvedWebPassword,
       authToken: resolvedAuthToken,
       port: typeof body.port === 'number' ? body.port : current.port,

package/app/app/api/sync/route.ts

@@ -1,6 +1,6 @@
 export const dynamic = 'force-dynamic';
 import { NextRequest, NextResponse } from 'next/server';
-import { execSync, exec } from 'child_process';
+import { execSync, execFile } from 'child_process';
 import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { join, resolve } from 'path';
 import { homedir } from 'os';
@@ -42,13 +42,11 @@ function getCliPath() {
   return resolve(process.cwd(), '..', 'bin', 'cli' + '.js');
 }
 
-/** Run CLI command via shell string — avoids Turbopack static analysis of file paths */
+/** Run CLI command via execFile — avoids shell injection by passing args as array */
 function runCli(args: string[], timeoutMs = 30000): Promise<void> {
   const cliPath = getCliPath();
-  const escaped = args.map(a => `'${a.replace(/'/g, "'\\''")}'`).join(' ');
-  const cmd = `${process.execPath} ${cliPath} ${escaped}`;
   return new Promise((res, rej) => {
-    exec(cmd, { timeout: timeoutMs }, (err, _stdout, stderr) => {
+    execFile(process.execPath, [cliPath, ...args], { timeout: timeoutMs }, (err, _stdout, stderr) => {
       if (err) rej(new Error(stderr?.trim() || err.message));
       else res();
     });

package/app/components/AskModal.tsx

@@ -28,7 +28,6 @@ export default function AskModal({ open, onClose, currentFile }: AskModalProps)
   const [isLoading, setIsLoading] = useState(false);
   const [loadingPhase, setLoadingPhase] = useState<'connecting' | 'thinking' | 'streaming'>('connecting');
   const [attachedFiles, setAttachedFiles] = useState<string[]>([]);
-  const [maxSteps, setMaxSteps] = useState(20);
   const [showHistory, setShowHistory] = useState(false);
 
   const session = useAskSession(currentFile);
@@ -136,7 +135,6 @@ export default function AskModal({ open, onClose, currentFile }: AskModalProps)
           currentFile,
           attachedFiles,
           uploadedFiles: upload.localAttachments,
-          maxSteps,
         }),
         signal: controller.signal,
       });
@@ -208,7 +206,7 @@ export default function AskModal({ open, onClose, currentFile }: AskModalProps)
       setIsLoading(false);
       abortRef.current = null;
     }
-  }, [input, session, isLoading, currentFile, attachedFiles, upload.localAttachments, mention.mentionQuery, maxSteps, t.ask.errorNoResponse, t.ask.stopped]);
+  }, [input, session, isLoading, currentFile, attachedFiles, upload.localAttachments, mention.mentionQuery, t.ask.errorNoResponse, t.ask.stopped]);
 
   const handleResetSession = useCallback(() => {
     if (isLoading) return;
@@ -287,7 +285,6 @@ export default function AskModal({ open, onClose, currentFile }: AskModalProps)
           emptyPrompt={t.ask.emptyPrompt}
           suggestions={t.ask.suggestions}
           onSuggestionClick={setInput}
-          maxSteps={maxSteps}
           labels={{ connecting: t.ask.connecting, thinking: t.ask.thinking, generating: t.ask.generating }}
         />
 
@@ -389,14 +386,6 @@ export default function AskModal({ open, onClose, currentFile }: AskModalProps)
         <div className="hidden md:flex px-4 pb-2 items-center gap-3 text-xs text-muted-foreground/50 shrink-0">
           <span><kbd className="font-mono">↵</kbd> {t.ask.send}</span>
           <span><kbd className="font-mono">@</kbd> {t.ask.attachFile}</span>
-          <span className="inline-flex items-center gap-1">
-            <span>Agent steps</span>
-            <select value={maxSteps} onChange={(e) => setMaxSteps(Number(e.target.value))} disabled={isLoading} className="bg-transparent border border-border rounded px-1.5 py-0.5 text-xs text-foreground">
-              <option value={10}>10</option>
-              <option value={20}>20</option>
-              <option value={30}>30</option>
-            </select>
-          </span>
           <span><kbd className="font-mono">ESC</kbd> {t.search.close}</span>
         </div>
       </div>

package/app/components/SettingsModal.tsx

@@ -6,7 +6,7 @@ import { useLocale } from '@/lib/LocaleContext';
 import { getAllRenderers, loadDisabledState, isRendererEnabled } from '@/lib/renderers/registry';
 import { apiFetch } from '@/lib/api';
 import '@/lib/renderers/index';
-import type { AiSettings, SettingsData, Tab } from './settings/types';
+import type { AiSettings, AgentSettings, SettingsData, Tab } from './settings/types';
 import { FONTS } from './settings/types';
 import { AiTab } from './settings/AiTab';
 import { AppearanceTab } from './settings/AppearanceTab';
@@ -88,7 +88,7 @@ export default function SettingsModal({ open, onClose, initialTab }: SettingsMod
       await apiFetch('/api/settings', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ ai: data.ai, mindRoot: data.mindRoot, webPassword: data.webPassword, authToken: data.authToken }),
+        body: JSON.stringify({ ai: data.ai, agent: data.agent, mindRoot: data.mindRoot, webPassword: data.webPassword, authToken: data.authToken }),
       });
       setStatus('saved');
       setTimeout(() => setStatus('idle'), 2500);
@@ -104,6 +104,10 @@ export default function SettingsModal({ open, onClose, initialTab }: SettingsMod
     setData(d => d ? { ...d, ai: { ...d.ai, ...patch } } : d);
   }, []);
 
+  const updateAgent = useCallback((patch: Partial<AgentSettings>) => {
+    setData(d => d ? { ...d, agent: { ...(d.agent ?? {}), ...patch } } : d);
+  }, []);
+
   const restoreFromEnv = useCallback(async () => {
     if (!data) return;
     const defaults: AiSettings = {
@@ -198,7 +202,7 @@ export default function SettingsModal({ open, onClose, initialTab }: SettingsMod
             </div>
           ) : (
             <>
-              {tab === 'ai' && data?.ai && <AiTab data={data} updateAi={updateAi} t={t} />}
+              {tab === 'ai' && data?.ai && <AiTab data={data} updateAi={updateAi} updateAgent={updateAgent} t={t} />}
               {tab === 'appearance' && <AppearanceTab font={font} setFont={setFont} contentWidth={contentWidth} setContentWidth={setContentWidth} dark={dark} setDark={setDark} locale={locale} setLocale={setLocale} t={t} />}
               {tab === 'knowledge' && data && <KnowledgeTab data={data} setData={setData} t={t} />}
               {tab === 'plugins' && <PluginsTab pluginStates={pluginStates} setPluginStates={setPluginStates} t={t} />}

package/app/components/ask/MessageList.tsx

@@ -6,6 +6,7 @@ import ReactMarkdown from 'react-markdown';
 import remarkGfm from 'remark-gfm';
 import type { Message } from '@/lib/types';
 import ToolCallBlock from './ToolCallBlock';
+import ThinkingBlock from './ThinkingBlock';
 
 function AssistantMessage({ content, isStreaming }: { content: string; isStreaming: boolean }) {
   return (
@@ -45,6 +46,10 @@ function AssistantMessageWithParts({ message, isStreaming }: { message: Message;
   return (
     <div>
       {parts.map((part, idx) => {
+        if (part.type === 'reasoning') {
+          const isLastPart = isStreaming && idx === parts.length - 1;
+          return <ThinkingBlock key={`reasoning-${idx}`} text={part.text} isStreaming={isLastPart} />;
+        }
         if (part.type === 'text') {
           const isLastTextPart = isStreaming && idx === parts.length - 1;
           return part.text ? (
@@ -66,7 +71,7 @@ function AssistantMessageWithParts({ message, isStreaming }: { message: Message;
   );
 }
 
-function StepCounter({ parts, maxSteps }: { parts: Message['parts']; maxSteps?: number }) {
+function StepCounter({ parts }: { parts: Message['parts'] }) {
   if (!parts) return null;
   const toolCalls = parts.filter(p => p.type === 'tool-call');
   if (toolCalls.length === 0) return null;
@@ -75,7 +80,7 @@ function StepCounter({ parts, maxSteps }: { parts: Message['parts']; maxSteps?:
   return (
     <div className="flex items-center gap-1.5 mt-1.5 text-xs text-muted-foreground/70">
       <Wrench size={10} />
-      <span>Step {toolCalls.length}{maxSteps ? `/${maxSteps}` : ''}{toolLabel ? ` — ${toolLabel}` : ''}</span>
+      <span>Step {toolCalls.length}{toolLabel ? ` — ${toolLabel}` : ''}</span>
     </div>
   );
 }
@@ -87,7 +92,6 @@ interface MessageListProps {
   emptyPrompt: string;
   suggestions: readonly string[];
   onSuggestionClick: (text: string) => void;
-  maxSteps?: number;
   labels: {
     connecting: string;
     thinking: string;
@@ -102,7 +106,6 @@ export default function MessageList({
   emptyPrompt,
   suggestions,
   onSuggestionClick,
-  maxSteps,
   labels,
 }: MessageListProps) {
   const endRef = useRef<HTMLDivElement>(null);
@@ -160,7 +163,7 @@ export default function MessageList({
                 <>
                   <AssistantMessageWithParts message={m} isStreaming={isLoading && i === messages.length - 1} />
                   {isLoading && i === messages.length - 1 && (
-                    <StepCounter parts={m.parts} maxSteps={maxSteps} />
+                    <StepCounter parts={m.parts} />
                   )}
                 </>
               ) : isLoading && i === messages.length - 1 ? (

package/app/components/ask/ThinkingBlock.tsx

@@ -0,0 +1,55 @@
+'use client';
+
+import { useState } from 'react';
+import { ChevronRight, ChevronDown, Brain } from 'lucide-react';
+import { useLocale } from '@/lib/LocaleContext';
+
+interface ThinkingBlockProps {
+  text: string;
+  isStreaming?: boolean;
+}
+
+export default function ThinkingBlock({ text, isStreaming }: ThinkingBlockProps) {
+  const [expanded, setExpanded] = useState(false);
+  const { t } = useLocale();
+
+  if (!text && !isStreaming) return null;
+
+  return (
+    <div className="my-1 rounded-md border border-border/40 bg-muted/20 text-xs">
+      <button
+        type="button"
+        onClick={() => setExpanded(v => !v)}
+        className="w-full flex items-center gap-1.5 px-2 py-1.5 text-left hover:bg-muted/30 transition-colors rounded-md"
+      >
+        {expanded ? (
+          <ChevronDown size={12} className="shrink-0 text-muted-foreground" />
+        ) : (
+          <ChevronRight size={12} className="shrink-0 text-muted-foreground" />
+        )}
+        <Brain size={12} className="shrink-0 text-muted-foreground" />
+        <span className="text-muted-foreground font-medium">
+          {t.ask.thinkingLabel}
+          {isStreaming && !expanded && (
+            <span className="ml-1 animate-pulse">...</span>
+          )}
+        </span>
+        {!expanded && text && (
+          <span className="text-muted-foreground/60 truncate flex-1 ml-1">
+            {text.slice(0, 80)}{text.length > 80 ? '...' : ''}
+          </span>
+        )}
+      </button>
+      {expanded && (
+        <div className="px-2 pb-2 pt-0.5 border-t border-border/30">
+          <div className="text-muted-foreground whitespace-pre-wrap leading-relaxed">
+            {text}
+            {isStreaming && (
+              <span className="inline-block w-1 h-3 bg-muted-foreground/40 ml-0.5 align-middle animate-pulse rounded-sm" />
+            )}
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}

package/app/components/ask/ToolCallBlock.tsx

@@ -1,9 +1,11 @@
 'use client';
 
 import { useState } from 'react';
-import { ChevronRight, ChevronDown, Loader2, CheckCircle2, XCircle } from 'lucide-react';
+import { ChevronRight, ChevronDown, Loader2, CheckCircle2, XCircle, AlertTriangle } from 'lucide-react';
 import type { ToolCallPart } from '@/lib/types';
 
+const DESTRUCTIVE_TOOLS = new Set(['delete_file', 'move_file', 'rename_file', 'write_file']);
+
 const TOOL_ICONS: Record<string, string> = {
   search: '🔍',
   list_files: '📂',
@@ -48,17 +50,23 @@ export default function ToolCallBlock({ part }: { part: ToolCallPart }) {
   const [expanded, setExpanded] = useState(false);
   const icon = TOOL_ICONS[part.toolName] ?? '🔧';
   const inputSummary = formatInput(part.input);
+  const isDestructive = DESTRUCTIVE_TOOLS.has(part.toolName);
 
   return (
-    <div className="my-1 rounded-md border border-border/50 bg-muted/30 text-xs font-mono">
+    <div className={`my-1 rounded-md border text-xs font-mono ${
+      isDestructive
+        ? 'border-amber-500/30 bg-amber-500/5'
+        : 'border-border/50 bg-muted/30'
+    }`}>
       <button
         type="button"
         onClick={() => setExpanded(v => !v)}
         className="w-full flex items-center gap-1.5 px-2 py-1.5 text-left hover:bg-muted/50 transition-colors rounded-md"
       >
         {expanded ? <ChevronDown size={12} className="shrink-0 text-muted-foreground" /> : <ChevronRight size={12} className="shrink-0 text-muted-foreground" />}
+        {isDestructive && <AlertTriangle size={11} className="shrink-0 text-amber-500" />}
         <span>{icon}</span>
-        <span className="text-foreground font-medium">{part.toolName}</span>
+        <span className={`font-medium ${isDestructive ? 'text-amber-600 dark:text-amber-400' : 'text-foreground'}`}>{part.toolName}</span>
         <span className="text-muted-foreground truncate flex-1">({inputSummary})</span>
         <span className="shrink-0 ml-auto">
           {part.state === 'pending' || part.state === 'running' ? (

package/app/components/settings/AiTab.tsx

@@ -2,7 +2,7 @@
 
 import { useState, useRef, useCallback, useEffect } from 'react';
 import { AlertCircle, Loader2 } from 'lucide-react';
-import type { AiSettings, ProviderConfig, SettingsData } from './types';
+import type { AiSettings, AgentSettings, ProviderConfig, SettingsData } from './types';
 import { Field, Select, Input, EnvBadge, ApiKeyInput } from './Primitives';
 
 type TestState = 'idle' | 'testing' | 'ok' | 'error';
@@ -28,10 +28,11 @@ function errorMessage(t: any, code?: ErrorCode): string {
 interface AiTabProps {
   data: SettingsData;
   updateAi: (patch: Partial<AiSettings>) => void;
+  updateAgent: (patch: Partial<AgentSettings>) => void;
   t: any;
 }
 
-export function AiTab({ data, updateAi, t }: AiTabProps) {
+export function AiTab({ data, updateAi, updateAgent, t }: AiTabProps) {
   const env = data.envOverrides ?? {};
   const envVal = data.envValues ?? {};
   const provider = data.ai.provider;
@@ -224,6 +225,79 @@ export function AiTab({ data, updateAi, t }: AiTabProps) {
           <span>{t.settings.ai.envHint}</span>
         </div>
       )}
+
+      {/* Agent Behavior */}
+      <div className="pt-3 border-t border-border">
+        <h3 className="text-xs font-semibold text-muted-foreground uppercase tracking-wider mb-3">{t.settings.agent.title}</h3>
+
+        <div className="space-y-4">
+          <Field label={t.settings.agent.maxSteps} hint={t.settings.agent.maxStepsHint}>
+            <Select
+              value={String(data.agent?.maxSteps ?? 20)}
+              onChange={e => updateAgent({ maxSteps: Number(e.target.value) })}
+            >
+              <option value="5">5</option>
+              <option value="10">10</option>
+              <option value="15">15</option>
+              <option value="20">20</option>
+              <option value="25">25</option>
+              <option value="30">30</option>
+            </Select>
+          </Field>
+
+          <Field label={t.settings.agent.contextStrategy} hint={t.settings.agent.contextStrategyHint}>
+            <Select
+              value={data.agent?.contextStrategy ?? 'auto'}
+              onChange={e => updateAgent({ contextStrategy: e.target.value as 'auto' | 'off' })}
+            >
+              <option value="auto">{t.settings.agent.contextStrategyAuto}</option>
+              <option value="off">{t.settings.agent.contextStrategyOff}</option>
+            </Select>
+          </Field>
+
+          {provider === 'anthropic' && (
+            <>
+              <div className="flex items-center justify-between">
+                <div>
+                  <div className="text-sm text-foreground">{t.settings.agent.thinking}</div>
+                  <div className="text-xs text-muted-foreground mt-0.5">{t.settings.agent.thinkingHint}</div>
+                </div>
+                <button
+                  type="button"
+                  role="switch"
+                  aria-checked={data.agent?.enableThinking ?? false}
+                  onClick={() => updateAgent({ enableThinking: !(data.agent?.enableThinking ?? false) })}
+                  className={`relative inline-flex h-5 w-9 shrink-0 cursor-pointer rounded-full border-2 border-transparent transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring ${
+                    data.agent?.enableThinking ? 'bg-amber-500' : 'bg-muted'
+                  }`}
+                >
+                  <span
+                    className={`pointer-events-none inline-block h-4 w-4 rounded-full bg-white shadow-sm transition-transform ${
+                      data.agent?.enableThinking ? 'translate-x-4' : 'translate-x-0'
+                    }`}
+                  />
+                </button>
+              </div>
+
+              {data.agent?.enableThinking && (
+                <Field label={t.settings.agent.thinkingBudget} hint={t.settings.agent.thinkingBudgetHint}>
+                  <Input
+                    type="number"
+                    value={String(data.agent?.thinkingBudget ?? 5000)}
+                    onChange={e => {
+                      const v = parseInt(e.target.value, 10);
+                      if (!isNaN(v)) updateAgent({ thinkingBudget: Math.max(1000, Math.min(50000, v)) });
+                    }}
+                    min={1000}
+                    max={50000}
+                    step={1000}
+                  />
+                </Field>
+              )}
+            </>
+          )}
+        </div>
+      </div>
     </div>
   );
 }

package/app/components/settings/types.ts

@@ -14,8 +14,16 @@ export interface AiSettings {
   };
 }
 
+export interface AgentSettings {
+  maxSteps?: number;
+  enableThinking?: boolean;
+  thinkingBudget?: number;
+  contextStrategy?: 'auto' | 'off';
+}
+
 export interface SettingsData {
   ai: AiSettings;
+  agent?: AgentSettings;
   mindRoot: string;
   webPassword?: string;
   authToken?: string;   // masked: first-xxxx-••••-last pattern