@bibobonking/opensol 3.0.2 → 3.1.0

package/src/components/ToolCallCard.tsx

@@ -1,10 +1,23 @@
 import { useEffect, useState } from 'react'
 import { ArrowRight } from 'lucide-react'
-import type { ToolMessage, ToolName } from '../types'
+import type { FileDiff, ToolMessage, ToolName } from '../types'
 import { toolLabel, toolSummary } from '../agent/tools'
 import { resolveApproval } from '../agent/approval'
 import { useUi } from '../store/ui'
 import { cn } from '../lib/utils'
+import { diffLines, diffStats } from '../lib/diff'
+import { DiffBadge, DiffView } from './DiffView'
+
+const FILE_TOOLS = new Set(['write_file', 'edit_file', 'rewrite_file'])
+
+/** The diff the daemon reported, or one worked out from the call itself for older chats. */
+export function diffForTool(message: ToolMessage): FileDiff | undefined {
+  if (message.diff) return message.diff
+  if (message.status !== 'done' || message.call.name !== 'edit_file') return undefined
+  const { oldText, newText } = message.call.args
+  if (typeof oldText !== 'string' || typeof newText !== 'string') return undefined
+  return diffStats(diffLines(oldText, newText))
+}
 
 function statusMeta(status: ToolMessage['status']) {
   switch (status) {
@@ -55,6 +68,8 @@ export function ToolCallCard({ message, compact = false }: { message: ToolMessag
   const status = statusMeta(message.status)
   const summary = toolSummary(message.call.name, message.call.args)
   const args = message.call.args
+  const diff = diffForTool(message)
+  const isFileTool = FILE_TOOLS.has(message.call.name)
   const command = typeof args.command === 'string' ? args.command : ''
   const content =
     typeof args.content === 'string'
@@ -87,7 +102,7 @@ export function ToolCallCard({ message, compact = false }: { message: ToolMessag
         : status.label.toLowerCase()
 
   return (
-    <div className="text-[12.5px]">
+    <div className="animate-slideleft text-[12.5px]">
       <button
         type="button"
         onClick={() => setOpen((value) => !value)}
@@ -104,10 +119,14 @@ export function ToolCallCard({ message, compact = false }: { message: ToolMessag
         />
         <span className="shrink-0 font-medium text-ink">{toolLabel(message.call.name)}</span>
         <span className="min-w-0 flex-1 truncate font-mono text-[11.5px] text-muted">{summary || '—'}</span>
-        {trailing && (
-          <span className={cn('shrink-0 text-[11px]', message.status === 'running' ? 'text-shimmer' : message.status === 'done' ? 'text-faint' : status.className)}>
-            {trailing}
-          </span>
+        {isFileTool && diff && message.status === 'done' ? (
+          <DiffBadge added={diff.added} removed={diff.removed} line={diff.line} column={diff.column} className="shrink-0" />
+        ) : (
+          trailing && (
+            <span className={cn('shrink-0 text-[11px]', message.status === 'running' ? 'text-shimmer' : message.status === 'done' ? 'text-faint' : status.className)}>
+              {trailing}
+            </span>
+          )
         )}
       </button>
 
@@ -140,7 +159,10 @@ export function ToolCallCard({ message, compact = false }: { message: ToolMessag
               $ {command}
             </pre>
           )}
-          {content && (
+          {message.call.name === 'edit_file' && typeof args.oldText === 'string' && typeof args.newText === 'string' && (
+            <DiffView before={args.oldText} after={args.newText} startLine={diff?.line ?? 1} />
+          )}
+          {content && message.call.name !== 'edit_file' && (
             <pre className="thin-scroll max-h-48 overflow-auto whitespace-pre-wrap break-words font-mono text-[11px] leading-relaxed text-muted">
               {content.length > 4000 ? `${content.slice(0, 4000)}\n… ${content.length - 4000} more characters` : content}
             </pre>

package/src/components/WorkspacePanel.tsx

@@ -26,6 +26,8 @@ import { cn, formatBytes } from '../lib/utils'
 import { useUi } from '../store/ui'
 import { useWorkspace } from '../store/workspace'
 import { PreviewPane } from './PreviewPane'
+import { SessionsTab } from './SessionsTab'
+import { useChats } from '../store/chats'
 import { Spinner } from './ui'
 
 interface TreeNode {
@@ -230,7 +232,8 @@ export function WorkspacePanel() {
 
   const [query, setQuery] = useState('')
   const [collapsed, setCollapsed] = useState<Set<string>>(new Set())
-  const [tab, setTab] = useState<'files' | 'preview' | 'git'>('files')
+  const sessionCount = useChats((state) => state.sessions.length)
+  const [tab, setTab] = useState<'files' | 'preview' | 'git' | 'sessions'>('files')
   const [choosing, setChoosing] = useState(!info.available)
   const [editor, setEditor] = useState<{ mode: 'create-file' | 'create-dir' | 'rename'; value: string } | null>(
     null,
@@ -457,6 +460,16 @@ export function WorkspacePanel() {
               >
                 Preview
               </button>
+              <button
+                type="button"
+                onClick={() => setTab('sessions')}
+                className={cn(
+                  'h-7 rounded-md px-2.5 text-[11px] font-medium',
+                  tab === 'sessions' ? 'bg-raised text-ink' : 'text-muted hover:text-ink',
+                )}
+              >
+                Sessions <span className="text-faint">· {sessionCount}</span>
+              </button>
               <button
                 type="button"
                 onClick={() => setTab('git')}
@@ -639,6 +652,8 @@ export function WorkspacePanel() {
               </>
             ) : tab === 'preview' ? (
               <PreviewPane />
+            ) : tab === 'sessions' ? (
+              <SessionsTab />
             ) : (
               <div className="thin-scroll min-h-0 flex-1 overflow-y-auto">
                 <div className="flex items-center gap-2 border-b border-line px-3 py-3">

package/src/core/kernel.ts

@@ -9,6 +9,7 @@ import { CompactionService } from './services/compaction'
 import { SubagentService } from './services/subagents'
 import { UiService } from './services/ui'
 import { AgentLoopService } from './services/agent-loop'
+import { TitleService } from './services/titles'
 
 import * as toolFs from './plugins/tools/fs'
 import * as toolShell from './plugins/tools/shell'
@@ -30,6 +31,7 @@ export function createAppKernel(): Context {
   ctx.plugin(SubagentService)
   ctx.plugin(UiService)
   ctx.plugin(AgentLoopService)
+  ctx.plugin(TitleService)
 
   // 2. Mount First-Party Tool Plugins
   ctx.plugin(toolFs)

package/src/core/mcp-tools.ts

@@ -0,0 +1,63 @@
+import type { AppSettings, ToolName, ToolSetting } from '../types'
+import { mcpCall } from '../lib/daemon'
+import { isMcpToolName, useMcp } from '../store/mcp'
+import type { ToolDefinition, ToolSchema } from './types'
+
+const MAX_OUTPUT = 28_000
+
+function toParameters(schema: Record<string, unknown>): ToolSchema['parameters'] {
+  const properties =
+    schema.properties && typeof schema.properties === 'object'
+      ? (schema.properties as Record<string, unknown>)
+      : {}
+  const required = Array.isArray(schema.required)
+    ? schema.required.filter((item): item is string => typeof item === 'string')
+    : undefined
+  return { type: 'object', properties, ...(required?.length ? { required } : {}) }
+}
+
+/** A connected, enabled MCP tool as a regular tool definition; null when it is not callable now. */
+export function mcpDefinition(name: ToolName): ToolDefinition | undefined {
+  if (!isMcpToolName(name)) return undefined
+  const hit = useMcp.getState().lookup(name)
+  if (!hit) return undefined
+  const { server, tool } = hit
+  if (!server.enabled || server.status !== 'connected' || server.disabledTools.includes(tool.name)) return undefined
+  return {
+    name,
+    description: `[MCP server “${server.name}”] ${tool.description || tool.name}`.slice(0, 1200),
+    parameters: toParameters(tool.inputSchema),
+    allowedInMode: (mode) => mode === 'build' || tool.readOnly,
+    async execute(args, exec) {
+      const { result } = await mcpCall(server.id, tool.name, args, exec.signal)
+      const text = result.text.trim() || '(the tool returned no output)'
+      return {
+        output: text.length > MAX_OUTPUT ? `${text.slice(0, MAX_OUTPUT)}\n… truncated (${text.length - MAX_OUTPUT} more characters)` : text,
+        isError: result.isError,
+      }
+    },
+  }
+}
+
+export function mcpDefinitions(): ToolDefinition[] {
+  const out: ToolDefinition[] = []
+  for (const server of useMcp.getState().servers) {
+    for (const tool of server.tools) {
+      const definition = mcpDefinition(tool.fn)
+      if (definition) out.push(definition)
+    }
+  }
+  return out
+}
+
+/** Enabled/approval for any tool: built-ins come from Settings → Tools, MCP tools from their server. */
+export function resolveToolSetting(settings: AppSettings, name: ToolName): ToolSetting | undefined {
+  if (!isMcpToolName(name)) return settings.tools[name]
+  const hit = useMcp.getState().lookup(name)
+  if (!hit) return undefined
+  const { server, tool } = hit
+  return {
+    enabled: server.enabled && server.status === 'connected' && !server.disabledTools.includes(tool.name),
+    approval: server.approval,
+  }
+}

package/src/core/plugins/tools/fs.ts

@@ -1,6 +1,7 @@
 import type { Context } from 'cordis'
 import { executeDaemonTool } from '../../../lib/daemon'
 import { useWorkspace } from '../../../store/workspace'
+import type { FileDiff } from '../../../types'
 import type { ToolResult } from '../../types'
 
 const MAX_TOOL_OUTPUT = 28_000
@@ -54,6 +55,20 @@ function formatList(result: Record<string, unknown>): string {
   return `${textValue(result.root) ? `Root: ${textValue(result.root)}\n` : ''}${lines.join('\n')}${suffix}`
 }
 
+function diffOf(result: Record<string, unknown>): FileDiff | undefined {
+  const raw = record(result.diff)
+  const added = numberValue(raw.added)
+  const removed = numberValue(raw.removed)
+  if (added === undefined || removed === undefined) return undefined
+  return { added, removed, line: numberValue(raw.line), column: numberValue(raw.column) }
+}
+
+function diffLabel(diff?: FileDiff) {
+  if (!diff) return ''
+  const where = diff.line ? ` at L${diff.line}${diff.column ? `:${diff.column}` : ''}` : ''
+  return ` · +${diff.added} −${diff.removed}${where}`
+}
+
 async function refreshWorkspace() {
   await useWorkspace.getState().refresh().catch(() => undefined)
 }
@@ -143,9 +158,11 @@ export function apply(ctx: Context) {
         const result = record((await executeDaemonTool('write_file', { path, content }, exec.mode, exec.signal, exec.turnId)).result)
         await refreshWorkspace()
         const verb = result.created === true ? 'Created' : 'Updated'
+        const diff = diffOf(result)
         return {
-          output: `${verb} ${textValue(result.path) || path} · ${content.split('\n').length} lines, ${numberValue(result.size) ?? content.length} bytes.`,
+          output: `${verb} ${textValue(result.path) || path} · ${content.split('\n').length} lines, ${numberValue(result.size) ?? content.length} bytes${diffLabel(diff)}.`,
           isError: false,
+          diff,
         }
       },
     }),
@@ -168,9 +185,11 @@ export function apply(ctx: Context) {
         const content = requireString(args, 'content')
         const result = record((await executeDaemonTool('rewrite_file', { path, content }, exec.mode, exec.signal, exec.turnId)).result)
         await refreshWorkspace()
+        const diff = diffOf(result)
         return {
-          output: `Rewrote ${textValue(result.path) || path} · ${content.split('\n').length} lines, ${numberValue(result.size) ?? content.length} bytes.`,
+          output: `Rewrote ${textValue(result.path) || path} · ${content.split('\n').length} lines, ${numberValue(result.size) ?? content.length} bytes${diffLabel(diff)}.`,
           isError: false,
+          diff,
         }
       },
     }),
@@ -207,9 +226,11 @@ export function apply(ctx: Context) {
           ).result,
         )
         await refreshWorkspace()
+        const diff = diffOf(result)
         return {
-          output: `Edited ${textValue(result.path) || path} · ${numberValue(result.replacements) ?? 1} replacement${numberValue(result.replacements) === 1 ? '' : 's'}.`,
+          output: `Edited ${textValue(result.path) || path} · ${numberValue(result.replacements) ?? 1} replacement${numberValue(result.replacements) === 1 ? '' : 's'}${diffLabel(diff)}.`,
           isError: false,
+          diff,
         }
       },
     }),

package/src/core/services/agent-loop.ts

@@ -8,6 +8,7 @@ import { getProviderName } from '../../data/providers'
 import { describeRequestError } from '../../lib/sse'
 import type { AdapterResult } from '../../agent/adapters/shared'
 import { createTurnQueue, lastUserMessageId } from '../../agent/queue'
+import { resolveToolSetting } from '../mcp-tools'
 import type { StepContext, StepResult, TurnResult } from '../types'
 
 const MAX_ROUNDS = 16
@@ -276,7 +277,7 @@ export class AgentLoopService extends Service {
 
         for (const call of result.toolCalls) {
           if (controller.signal.aborted) break
-          const toolSetting = settings.tools[call.name]
+          const toolSetting = resolveToolSetting(settings, call.name)
           if (!toolSetting?.enabled) {
             const message: ToolMessage = {
               id: createId('tool'),
@@ -332,6 +333,7 @@ export class AgentLoopService extends Service {
               status: output.isError ? 'error' : 'done',
               result: output.output,
               durationMs: Date.now() - toolStarted,
+              diff: output.diff,
             }
             this.ctx.sessions.updateMessage(sessionId, toolMessageId, finalToolMessage)
             toolMessages.push(finalToolMessage)

package/src/core/services/approval.ts

@@ -1,5 +1,6 @@
 import { Service, type Context } from 'cordis'
 import type { ToolExecutionContext, ToolPreExecuteResult } from '../types'
+import { resolveToolSetting } from '../mcp-tools'
 
 interface PendingApproval {
   toolCallId: string
@@ -18,7 +19,7 @@ export class ApprovalService extends Service {
 
     // Attach to tools/pre-execute waterfall gate
     this.ctx.on('tools/pre-execute', async (exec: ToolExecutionContext, next: () => Promise<ToolPreExecuteResult>) => {
-      const toolSetting = exec.settings.tools[exec.name]
+      const toolSetting = resolveToolSetting(exec.settings, exec.name)
       if (toolSetting?.approval === 'ask' && exec.callId) {
         const approved = await this.waitForApproval(exec.callId, exec.signal)
         if (!approved) {

package/src/core/services/titles.ts

@@ -0,0 +1,135 @@
+import { Service, type Context } from 'cordis'
+import type { AppSettings, BuiltinToolName, Message } from '../../types'
+import { activeModelId, useSettings } from '../../store/settings'
+import { useChats } from '../../store/chats'
+import { useRuntime } from '../../store/ui'
+import { findModel } from '../../store/models'
+import { effortOptions } from '../../lib/reasoning'
+import { createId } from '../../store/chats'
+import type { TurnResult } from '../types'
+
+const TITLE_SYSTEM =
+  'You name chat sessions for a coding assistant. Reply with the title only: 2 to 6 words, in the same language as the user, no quotes, no markdown, no trailing punctuation.'
+
+function clip(value: string, max: number) {
+  const clean = value.replace(/\s+/g, ' ').trim()
+  return clean.length > max ? `${clean.slice(0, max)}…` : clean
+}
+
+export function cleanTitle(raw: string): string {
+  const first = raw
+    .replace(/<think>[\s\S]*?<\/think>/gi, '')
+    .split('\n')
+    .map((line) => line.trim())
+    .find(Boolean)
+  if (!first) return ''
+  const title = first
+    .replace(/^(title|tiêu đề)\s*[:：-]\s*/i, '')
+    .replace(/^[#>*\-\s"'“”‘’`]+|[\s"'“”‘’`.。!]+$/g, '')
+    .trim()
+  return title.length > 64 ? `${title.slice(0, 63).trim()}…` : title
+}
+
+function excerpt(messages: Message[]) {
+  const user = messages.find((message) => message.role === 'user')
+  const assistant = [...messages].reverse().find((message) => message.role === 'assistant' && message.content.trim())
+  return {
+    user: user && user.role === 'user' ? clip(user.content, 700) : '',
+    assistant: assistant && assistant.role === 'assistant' ? clip(assistant.content, 700) : '',
+  }
+}
+
+/** Lets the model name a session after its first answer, or on demand from the sidebar. */
+export class TitleService extends Service {
+  static provide = 'titles'
+  static inject = ['llm', 'sessions']
+
+  private inflight = new Set<string>()
+
+  constructor(ctx: Context) {
+    super(ctx, 'titles')
+    this.ctx.on('agent/turn-finish', (turn: TurnResult) => {
+      if (turn.error || turn.stopped) return
+      const settings = useSettings.getState()
+      if (!settings.aiSessionTitles) return
+      const session = this.ctx.sessions.current(turn.sessionId)
+      // Only a title that is still the first-message excerpt may be replaced; names the person typed stay.
+      if (!session || (session.titleSource ?? 'auto') !== 'auto') return
+      void this.generate(turn.sessionId)
+    })
+  }
+
+  async generate(sessionId: string, { force = false } = {}): Promise<string | null> {
+    if (this.inflight.has(sessionId)) return null
+    const session = this.ctx.sessions.current(sessionId)
+    if (!session) return null
+    if (!force && (session.titleSource ?? 'auto') !== 'auto') return null
+    const { user, assistant } = excerpt(session.messages)
+    if (!user) return null
+
+    const settings = useSettings.getState()
+    const model = findModel(settings.provider, activeModelId(settings))
+    // No tools, no web, the lowest reasoning effort the model offers: a title is not worth a thinking budget.
+    const tools = Object.fromEntries(
+      Object.entries(settings.tools).map(([name, value]) => [name, { ...value, enabled: false }]),
+    ) as Record<BuiltinToolName, AppSettings['tools'][BuiltinToolName]>
+    const efforts = effortOptions(model)
+    const titleSettings: AppSettings = {
+      ...settings,
+      tools,
+      webSearchEnabled: false,
+      temperature: 0.3,
+      maxTokens: 512,
+      effort: efforts[0] ?? settings.effort,
+    }
+    const history: Message[] = [
+      {
+        id: createId('title'),
+        role: 'user',
+        createdAt: Date.now(),
+        content: `Name this conversation.\n\nUser: ${user}\n\nAssistant: ${assistant || '(no answer yet)'}`,
+      },
+    ]
+
+    this.inflight.add(sessionId)
+    useRuntime.getState().setTitling(sessionId, true)
+    try {
+      const controller = new AbortController()
+      const timer = window.setTimeout(() => controller.abort(), 25_000)
+      let streamed = ''
+      const result = await this.ctx.llm
+        .stream({
+          settings: titleSettings,
+          model,
+          history,
+          system: TITLE_SYSTEM,
+          mode: 'plan',
+          signal: controller.signal,
+          handlers: {
+            onText: (delta) => {
+              streamed += delta
+            },
+            onReasoning: () => undefined,
+            onToolCalls: () => undefined,
+            onUsage: () => undefined,
+          },
+        })
+        .finally(() => window.clearTimeout(timer))
+      const title = cleanTitle(result.content || streamed)
+      const latest = this.ctx.sessions.current(sessionId)
+      if (!title || !latest) return null
+      if (!force && (latest.titleSource ?? 'auto') !== 'auto') return null
+      this.ctx.sessions.updateSession(sessionId, { title, titleSource: 'ai' })
+      return title
+    } catch {
+      return null
+    } finally {
+      this.inflight.delete(sessionId)
+      useRuntime.getState().setTitling(sessionId, false)
+    }
+  }
+}
+
+export function sessionTitleSource(sessionId: string) {
+  return useChats.getState().sessions.find((session) => session.id === sessionId)?.titleSource
+}

package/src/core/services/tools.ts

@@ -1,5 +1,6 @@
 import { Service, type Context } from 'cordis'
 import type { AgentMode, AppSettings, ToolName } from '../../types'
+import { mcpDefinition, mcpDefinitions, resolveToolSetting } from '../mcp-tools'
 import type {
   ToolDefinition,
   ToolExecutionContext,
@@ -39,11 +40,11 @@ export class ToolService extends Service {
   }
 
   get(name: ToolName): ToolDefinition | undefined {
-    return this.definitions.get(name)
+    return this.definitions.get(name) ?? mcpDefinition(name)
   }
 
   list(): ToolDefinition[] {
-    return [...this.definitions.values()]
+    return [...this.definitions.values(), ...mcpDefinitions()]
   }
 
   schemas(
@@ -52,9 +53,11 @@ export class ToolService extends Service {
     { subagent = false }: { subagent?: boolean } = {},
   ): ToolSchema[] {
     const list: ToolSchema[] = []
-    for (const def of this.definitions.values()) {
+    // Subagents stay on the built-in read-only tools; MCP tools are not offered to them.
+    const all = subagent ? [...this.definitions.values()] : this.list()
+    for (const def of all) {
       if (def.name === 'subagent' && subagent) continue
-      if (!settings.tools[def.name]?.enabled) continue
+      if (!resolveToolSetting(settings, def.name)?.enabled) continue
       const allowed = def.allowedInMode ? def.allowedInMode(mode) : toolAllowedInMode(def.name, mode)
       if (!allowed) continue
       if ((def.name === 'web_search' || def.name === 'read_url') && !settings.webSearchEnabled) continue
@@ -83,10 +86,10 @@ export class ToolService extends Service {
       'tools/pre-execute',
       exec,
       async () => {
-        if (!settings.tools[name]?.enabled) {
-          return { decision: 'deny', reason: 'This tool is disabled in Settings → Tools.' }
+        if (!resolveToolSetting(settings, name)?.enabled) {
+          return { decision: 'deny', reason: 'This tool is disabled or its MCP server is not connected (Settings → Tools / MCP).' }
         }
-        const def = this.definitions.get(name)
+        const def = this.get(name)
         const allowed = def?.allowedInMode ? def.allowedInMode(mode) : toolAllowedInMode(name, mode)
         if (!allowed) {
           return {
@@ -113,7 +116,7 @@ export class ToolService extends Service {
 
     // 2. tools/execute waterfall
     const result: ToolResult = await this.ctx.events.waterfall('tools/execute', exec, async () => {
-      const def = this.definitions.get(name)
+      const def = this.get(name)
       if (!def) {
         return { output: `Tool "${name}" is not registered.`, isError: true }
       }

package/src/core/types.ts

@@ -2,6 +2,7 @@ import type {
   AgentMode,
   AppSettings,
   AssistantMessage,
+  FileDiff,
   Message,
   ModelInfo,
   ToolCall,
@@ -32,6 +33,8 @@ export interface ToolSchema {
 export interface ToolResult {
   output: string
   isError: boolean
+  /** Set by file tools so the UI can show +added / −removed lines. */
+  diff?: FileDiff
 }
 
 export interface ToolExecutionContext {
@@ -120,6 +123,7 @@ declare module 'cordis' {
     subagents: import('./services/subagents').SubagentService
     agentLoop: import('./services/agent-loop').AgentLoopService
     ui: import('./services/ui').UiService
+    titles: import('./services/titles').TitleService
   }
 
   interface Events {

package/src/index.css

@@ -222,7 +222,15 @@
   }
 
   .settings-row {
-    @apply flex flex-col gap-2 border-b border-line py-4 last:border-b-0 sm:flex-row sm:items-center sm:justify-between sm:gap-6;
+    @apply -mx-3 flex flex-col gap-2 rounded-2xl border-b border-transparent px-3 py-4 transition-colors duration-200 hover:bg-raised/50 sm:flex-row sm:items-center sm:justify-between sm:gap-6;
+  }
+
+  .settings-card {
+    @apply relative rounded-2xl border border-line bg-panel p-4 shadow-pill transition-all duration-300 sm:p-5;
+  }
+
+  .settings-card:hover {
+    border-color: rgb(var(--accent) / 0.25);
   }
 
   .settings-label {
@@ -774,3 +782,91 @@
   33% { transform: translateX(0); }
   66% { transform: translateX(1px); }
 }
+
+
+/* ───────── v3.1 motion & animation ───────── */
+
+.settings-enter > * {
+  animation: rise 0.55s cubic-bezier(0.16, 1, 0.3, 1) both;
+}
+.settings-enter > *:nth-child(2) { animation-delay: 60ms; }
+.settings-enter > *:nth-child(3) { animation-delay: 120ms; }
+.settings-enter > *:nth-child(4) { animation-delay: 180ms; }
+.settings-enter > *:nth-child(n + 5) { animation-delay: 240ms; }
+
+.settings-title-in {
+  animation: blurin 0.55s cubic-bezier(0.16, 1, 0.3, 1) both;
+}
+
+.settings-shell {
+  animation: shell-in 0.42s cubic-bezier(0.16, 1, 0.3, 1) backwards;
+}
+
+.settings-glow {
+  background:
+    radial-gradient(120% 100% at 0% 0%, rgb(var(--accent) / 0.16), transparent 65%),
+    radial-gradient(80% 80% at 100% 0%, rgb(var(--accent) / 0.06), transparent 70%);
+}
+
+@keyframes shell-in {
+  from { opacity: 0; transform: translateY(18px) scale(0.975); filter: blur(6px); }
+  to { opacity: 1; transform: none; filter: blur(0); }
+}
+
+/* Model deck */
+.deck-scrim { animation: fade 0.25s ease-out both; }
+.deck-panel { animation: deck-in 0.5s cubic-bezier(0.16, 1, 0.3, 1) backwards; }
+.deck-row { animation: deck-row 0.4s cubic-bezier(0.16, 1, 0.3, 1) backwards; }
+.deck-pop { animation: scalein 0.5s cubic-bezier(0.34, 1.56, 0.64, 1) both; }
+.deck-aurora {
+  background:
+    radial-gradient(70% 120% at 12% 0%, rgb(var(--accent) / 0.18), transparent 70%),
+    radial-gradient(50% 100% at 95% 0%, rgb(var(--accent) / 0.07), transparent 70%);
+}
+.deck-throttle {
+  background-image: radial-gradient(rgb(var(--line)) 1px, transparent 1px);
+  background-size: 14px 14px;
+  background-color: rgb(var(--canvas) / 0.7);
+}
+.throttle-knob { box-shadow: 0 0 0 4px rgb(var(--accent) / 0.16), 0 6px 18px -6px rgb(var(--accent) / 0.55); }
+.throttle-knob::after {
+  content: '';
+  position: absolute;
+  inset: -6px;
+  border-radius: 9999px;
+  border: 1px solid rgb(var(--accent) / 0.5);
+  animation: ping 2.4s cubic-bezier(0, 0, 0.2, 1) infinite;
+}
+.deck-trigger:active { transform: scale(0.96); }
+
+@keyframes deck-in {
+  from { opacity: 0; transform: translateY(24px) scale(0.96); filter: blur(8px); }
+  to { opacity: 1; transform: none; filter: blur(0); }
+}
+@keyframes deck-row {
+  from { opacity: 0; transform: translateX(-10px); }
+  to { opacity: 1; transform: none; }
+}
+
+/* Diff rows slide in as a tool card opens. */
+.diff-row { animation: deck-row 0.35s cubic-bezier(0.16, 1, 0.3, 1) backwards; }
+.diff-badge { animation: scalein 0.4s cubic-bezier(0.34, 1.56, 0.64, 1) both; }
+
+/* Messages and tool rows arrive with a soft rise. */
+.msg-enter { animation: rise 0.5s cubic-bezier(0.16, 1, 0.3, 1) both; }
+
+/* Buttons feel physical. */
+button:not(:disabled) { -webkit-tap-highlight-color: transparent; }
+.chip, .nav-item, .sidebar-item { will-change: transform; }
+
+/* Streaming caret and send-button pulse while the agent works. */
+.session-card:hover { transform: translateX(2px); }
+
+@media (prefers-reduced-motion: reduce) {
+  *, *::before, *::after {
+    animation-duration: 0.001ms !important;
+    animation-iteration-count: 1 !important;
+    transition-duration: 0.001ms !important;
+    scroll-behavior: auto !important;
+  }
+}