@steerable/agent-shell-web 0.6.27 → 0.6.29

package/src/components/chat/process-status.ts

@@ -1,16 +1,23 @@
 /**
- * Turn-process status line: live 「思考中 / 调用工具中」 plus finished
- * 「N 次工具调用 · 已思考 · 工作了 …」. Token speed is a coarse estimate
- * from reasoning text (same CJK/other weights as the desktop compactor).
+ * Work-row summary vs per-thinking-fold live stats.
+ * Footer tok/s is the model HTTP-stream generation speed across every
+ * output stage (reasoning + reply), excluding tool-wait gaps.
  */
 
 import { formatElapsedCompact } from './elapsed';
 import {
+  countProcessReasoning,
   countProcessTools,
-  processHasReasoning,
   type TurnBlock,
 } from './turn-timeline';
 
+/** Fallback thinking duration for legacy timelines that never stored durationMs. */
+export function estimateReasoningDurationMs(content: string): number | undefined {
+  const tokens = estimateTextTokens(content);
+  if (tokens < 4) return undefined;
+  return Math.max(1000, Math.round((tokens / 35) * 1000));
+}
+
 export function estimateTextTokens(text: string): number {
   if (!text) return 0;
   let cjk = 0;
@@ -35,22 +42,6 @@ export function formatTokenSpeed(tokens: number, elapsedMs: number): string | nu
   return `${shown} tok/s`;
 }
 
-export function estimateProcessReasoningTokens(process: TurnBlock[]): number {
-  let tokens = 0;
-  for (const block of process) {
-    if (block.type === 'reasoning') tokens += estimateTextTokens(block.content);
-  }
-  return tokens;
-}
-
-function speedElapsedMs(
-  reasoningElapsedMs: number | undefined,
-  elapsedMs: number | undefined,
-): number {
-  if (reasoningElapsedMs != null && reasoningElapsedMs >= 400) return reasoningElapsedMs;
-  return elapsedMs ?? reasoningElapsedMs ?? 0;
-}
-
 export function lastToolsAreRunning(process: TurnBlock[]): boolean {
   const last = process[process.length - 1];
   if (last?.type !== 'tools' || last.actions.length === 0) return false;
@@ -69,54 +60,135 @@ export function activeToolNames(process: TurnBlock[]): string[] {
 }
 
 function formatElapsedPart(
-  isStreaming: boolean,
+  isLive: boolean,
   elapsedMs: number | undefined,
 ): string | null {
   if (elapsedMs == null) return null;
-  if (!isStreaming && elapsedMs < 1000) return null;
+  if (!isLive && elapsedMs < 1000) return null;
   return formatElapsedCompact(elapsedMs);
 }
 
+/** Work disclosure: live is only 「工作中」; finished is a counts + duration summary. */
 export function processStatusLabel(input: {
   process: TurnBlock[];
   isStreaming: boolean;
   elapsedMs?: number;
-  reasoningElapsedMs?: number;
 }): string {
-  const { process, isStreaming, elapsedMs, reasoningElapsedMs } = input;
-  const elapsed = formatElapsedPart(isStreaming, elapsedMs);
-
-  if (isStreaming) {
-    const parts: string[] = [];
-    const last = process[process.length - 1];
-    if (lastToolsAreRunning(process)) {
-      parts.push('调用工具中');
-      const names = activeToolNames(process);
-      if (names.length > 0) parts.push(names.join('、'));
-    } else {
-      parts.push('思考中');
-      const tokens =
-        last?.type === 'reasoning'
-          ? estimateTextTokens(last.content)
-          : estimateProcessReasoningTokens(process);
-      const speed = formatTokenSpeed(
-        tokens,
-        speedElapsedMs(
-          last?.type === 'reasoning' ? reasoningElapsedMs : undefined,
-          elapsedMs,
-        ),
-      );
-      if (speed) parts.push(speed);
-    }
-    if (elapsed) parts.push(elapsed);
-    return parts.join(' · ');
-  }
+  const { process, isStreaming, elapsedMs } = input;
+  if (isStreaming) return '工作中';
 
   const parts: string[] = [];
+  const thinks = countProcessReasoning(process);
   const tools = countProcessTools(process);
-  if (tools > 0) parts.push(`${tools} 次工具调用`);
-  if (processHasReasoning(process)) parts.push('已思考');
+  const elapsed = formatElapsedPart(false, elapsedMs);
   if (elapsed) parts.push(`工作了 ${elapsed}`);
+  if (thinks > 0) parts.push(`思考 ${thinks} 次`);
+  if (tools > 0) parts.push(`工具调用 ${tools} 次`);
   if (parts.length === 0) return '执行过程';
   return parts.join(' · ');
 }
+
+/** Per-round 思考 fold: live time, or frozen duration after that round ends. */
+export function thinkingFoldLabel(input: {
+  content: string;
+  isLive: boolean;
+  elapsedMs?: number;
+}): string {
+  const elapsed = formatElapsedPart(input.isLive, input.elapsedMs);
+  if (input.isLive) {
+    return elapsed ? `思考中 · ${elapsed}` : '思考中';
+  }
+  return elapsed ? `思考 · ${elapsed}` : '思考';
+}
+
+/** Reasoning + reply tokens for the message-footer tok/s. */
+export function estimateTurnTokens(blocks: TurnBlock[], fallbackContent = ''): number {
+  if (blocks.length === 0) return estimateTextTokens(fallbackContent);
+  let tokens = 0;
+  for (const block of blocks) {
+    if (block.type === 'reasoning' || block.type === 'text') {
+      tokens += estimateTextTokens(block.content);
+    }
+  }
+  return tokens;
+}
+
+/** Snapshot of model-request generation speed (all LLM output stages). */
+export type LlmSpeedSnapshot = {
+  tokens: number;
+  elapsedMs: number;
+  live: boolean;
+  closedMs: number;
+  requestStartedAt: number | null;
+};
+
+export function parseLlmSpeedPayload(payload: unknown): LlmSpeedSnapshot | null {
+  if (!payload || typeof payload !== 'object') return null;
+  const value = payload as Record<string, unknown>;
+  if (typeof value.tokens !== 'number' || typeof value.elapsedMs !== 'number') {
+    return null;
+  }
+  return {
+    tokens: value.tokens,
+    elapsedMs: value.elapsedMs,
+    live: value.live === true,
+    closedMs: typeof value.closedMs === 'number' ? value.closedMs : value.elapsedMs,
+    requestStartedAt:
+      typeof value.requestStartedAt === 'number' ? value.requestStartedAt : null,
+  };
+}
+
+export function llmRequestElapsedMs(
+  snap: LlmSpeedSnapshot | null | undefined,
+  now: number,
+): number {
+  if (!snap) return 0;
+  if (snap.live && snap.requestStartedAt != null) {
+    return snap.closedMs + Math.max(0, now - snap.requestStartedAt);
+  }
+  return snap.elapsedMs;
+}
+
+/**
+ * Accumulates tokens + elapsed only while the model is streaming.
+ * `endRequest` freezes the current burst so tool waits do not dilute tok/s.
+ */
+export class LlmRequestSpeedTracker {
+  private requestStartedAt: number | null = null;
+  private requestText = '';
+  private closedText = '';
+  private closedMs = 0;
+
+  noteOutput(delta: string, now = Date.now()): LlmSpeedSnapshot {
+    if (delta) {
+      if (this.requestStartedAt == null) this.requestStartedAt = now;
+      this.requestText += delta;
+    }
+    return this.snapshot(now);
+  }
+
+  endRequest(now = Date.now()): LlmSpeedSnapshot {
+    if (this.requestStartedAt != null) {
+      this.closedText += this.requestText;
+      this.closedMs += Math.max(0, now - this.requestStartedAt);
+      this.requestStartedAt = null;
+      this.requestText = '';
+    }
+    return this.snapshot(now);
+  }
+
+  snapshot(now = Date.now()): LlmSpeedSnapshot {
+    const tokens = estimateTextTokens(this.closedText + this.requestText);
+    let elapsedMs = this.closedMs;
+    if (this.requestStartedAt != null) {
+      elapsedMs += Math.max(0, now - this.requestStartedAt);
+    }
+    return {
+      tokens,
+      elapsedMs,
+      live: this.requestStartedAt != null,
+      closedMs: this.closedMs,
+      requestStartedAt: this.requestStartedAt,
+    };
+  }
+}

package/src/components/chat/todo-list-model.ts

@@ -0,0 +1,167 @@
+/**
+ * Session task list — the UI half of `todo_write`.
+ *
+ * The tool is full-replace: each call carries the complete list. The latest
+ * successful rewrite (or the in-flight arguments, before the result lands)
+ * is the session header; older calls in the transcript stay as snapshots.
+ */
+
+import type { ExecutedAction } from './ExecutedActionsCard';
+import type { TurnBlock } from './turn-timeline';
+
+export const TODO_STATUSES = ['pending', 'in_progress', 'completed'] as const;
+export type TodoStatus = (typeof TODO_STATUSES)[number];
+
+export interface SessionTodo {
+  id: string;
+  content: string;
+  status: TodoStatus;
+}
+
+export interface SessionTodoSummary {
+  total: number;
+  pending: number;
+  inProgress: number;
+  completed: number;
+}
+
+const STATUS_SET = new Set<string>(TODO_STATUSES);
+
+function asObject(value: unknown): Record<string, unknown> | null {
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    if (!trimmed.startsWith('{') && !trimmed.startsWith('[')) return null;
+    try {
+      return asObject(JSON.parse(trimmed) as unknown);
+    } catch {
+      return null;
+    }
+  }
+  if (value && typeof value === 'object' && !Array.isArray(value)) {
+    return value as Record<string, unknown>;
+  }
+  return null;
+}
+
+function coerceTodos(raw: unknown): SessionTodo[] | null {
+  if (!Array.isArray(raw) || raw.length === 0) return null;
+  const todos: SessionTodo[] = [];
+  for (const item of raw) {
+    if (!item || typeof item !== 'object') return null;
+    const row = item as Record<string, unknown>;
+    const id = typeof row.id === 'string' ? row.id : '';
+    const content = typeof row.content === 'string' ? row.content.trim() : '';
+    const status = row.status;
+    if (!id || !content || typeof status !== 'string' || !STATUS_SET.has(status)) {
+      return null;
+    }
+    todos.push({ id, content, status: status as TodoStatus });
+  }
+  return todos.length > 0 ? todos : null;
+}
+
+/** Pull a todos array out of args, a tool result, or the sidecar envelope. */
+export function parseTodosPayload(value: unknown): SessionTodo[] | null {
+  if (Array.isArray(value)) return coerceTodos(value);
+  const obj = asObject(value);
+  if (!obj) return null;
+  if (Array.isArray(obj.todos)) return coerceTodos(obj.todos);
+  const data = asObject(obj.data);
+  if (data) {
+    if (Array.isArray(data.todos)) return coerceTodos(data.todos);
+    const inner = asObject(data.value);
+    if (inner && Array.isArray(inner.todos)) return coerceTodos(inner.todos);
+  }
+  const wrapped = asObject(obj.value);
+  if (wrapped && Array.isArray(wrapped.todos)) return coerceTodos(wrapped.todos);
+  return null;
+}
+
+export function extractTodosFromAction(action: {
+  tool: string;
+  arguments?: unknown;
+  result?: unknown;
+}): SessionTodo[] | null {
+  if (action.tool !== 'todo_write') return null;
+  return parseTodosPayload(action.result) ?? parseTodosPayload(action.arguments);
+}
+
+export function summarizeTodos(todos: SessionTodo[]): SessionTodoSummary {
+  const summary: SessionTodoSummary = {
+    total: todos.length,
+    pending: 0,
+    inProgress: 0,
+    completed: 0,
+  };
+  for (const todo of todos) {
+    if (todo.status === 'pending') summary.pending += 1;
+    else if (todo.status === 'in_progress') summary.inProgress += 1;
+    else summary.completed += 1;
+  }
+  return summary;
+}
+
+export function summarizeTodoWriteAction(
+  tool: string,
+  args: unknown,
+  result: unknown,
+): string | null {
+  if (tool !== 'todo_write') return null;
+  const todos = extractTodosFromAction({ tool, arguments: args, result });
+  if (!todos) return '任务清单';
+  const { completed, total, inProgress } = summarizeTodos(todos);
+  const current = todos.find((todo) => todo.status === 'in_progress');
+  if (inProgress > 0 && current) {
+    const label =
+      current.content.length > 28 ? `${current.content.slice(0, 25)}…` : current.content;
+    return `任务清单 ${completed}/${total} · ${label}`;
+  }
+  if (completed === total) return `任务清单 ${completed}/${total} 已完成`;
+  return `任务清单 ${completed}/${total}`;
+}
+
+export function latestTodosFromActions(
+  actions: Array<{ tool: string; arguments?: unknown; result?: unknown }> | undefined,
+): SessionTodo[] | null {
+  if (!actions || actions.length === 0) return null;
+  for (let i = actions.length - 1; i >= 0; i -= 1) {
+    const todos = extractTodosFromAction(actions[i]);
+    if (todos) return todos;
+  }
+  return null;
+}
+
+function actionsFromTimeline(blocks: TurnBlock[] | undefined): ExecutedAction[] {
+  if (!blocks) return [];
+  const actions: ExecutedAction[] = [];
+  for (const block of blocks) {
+    if (block.type === 'tools') actions.push(...block.actions);
+  }
+  return actions;
+}
+
+/**
+ * Newest `todo_write` list for the open chat. Live turn first, then
+ * historical actions / timelines walking messages newest-first.
+ */
+export function resolveLatestSessionTodos(input: {
+  messages: Array<{ id: string }>;
+  executedActionsByMessageId?: Record<string, ExecutedAction[]>;
+  currentTurnActions?: ExecutedAction[];
+  timelineByMessageId?: Record<string, TurnBlock[]>;
+  currentTurnTimeline?: TurnBlock[];
+}): SessionTodo[] | null {
+  const live =
+    latestTodosFromActions(input.currentTurnActions) ??
+    latestTodosFromActions(actionsFromTimeline(input.currentTurnTimeline));
+  if (live) return live;
+
+  for (let i = input.messages.length - 1; i >= 0; i -= 1) {
+    const id = input.messages[i].id;
+    const historical =
+      latestTodosFromActions(input.executedActionsByMessageId?.[id]) ??
+      latestTodosFromActions(actionsFromTimeline(input.timelineByMessageId?.[id]));
+    if (historical) return historical;
+  }
+  return null;
+}

package/src/components/chat/turn-timeline.ts

@@ -11,35 +11,114 @@
 import type { ExecutedAction } from './ExecutedActionsCard';
 
 export type TurnBlock =
-  | { type: 'reasoning'; content: string }
-  | { type: 'text'; content: string }
+  | {
+      type: 'reasoning';
+      content: string;
+      sealed?: boolean;
+      startedAtMs?: number;
+      durationMs?: number;
+    }
+  | { type: 'text'; content: string; sealed?: boolean }
   | { type: 'tools'; actions: ExecutedAction[] };
 
+/**
+ * 内容指纹：只要屏上会多出/变化一行，它就变。过程面板用它决定「要不要把
+ * 视口重新钉到底部」。
+ *
+ * 只数文本长度与工具条数是不够的：工具结果落回时条数不变、状态却从
+ * 「执行中」变「已完成」并展开出摘要，高度会长——那种增长必须也算变化，
+ * 否则跟随会在最常见的一种增长上失灵。
+ *
+ * @param blocks 当前时间线。
+ * @returns 稳定的内容指纹。
+ */
+export function timelineContentSignature(blocks: readonly TurnBlock[]): string {
+  return blocks
+    .map((block) => {
+      if (block.type !== 'tools') return `c${block.content.length}`;
+      const rows = block.actions
+        .map((action) => `${action.tool}:${action.result === undefined ? 0 : 1}`)
+        .join(',');
+      return `t${block.actions.length}[${rows}]`;
+    })
+    .join('|');
+}
+
+function freezeReasoningBlock(
+  block: Extract<TurnBlock, { type: 'reasoning' }>,
+  now: number,
+): Extract<TurnBlock, { type: 'reasoning' }> {
+  if (block.durationMs != null || block.startedAtMs == null) return block;
+  return { ...block, durationMs: Math.max(0, now - block.startedAtMs) };
+}
+
+/** Stamp duration on a trailing open reasoning block so the fold can keep 思考时间. */
+export function freezeReasoningDurations(
+  blocks: TurnBlock[],
+  now = Date.now(),
+): TurnBlock[] {
+  if (blocks.length === 0) return blocks;
+  const last = blocks[blocks.length - 1];
+  if (last.type !== 'reasoning') return blocks;
+  const frozen = freezeReasoningBlock(last, now);
+  if (frozen === last) return blocks;
+  const next = blocks.slice();
+  next[next.length - 1] = frozen;
+  return next;
+}
+
 export function appendDelta(
   blocks: TurnBlock[],
   type: 'text' | 'reasoning',
   delta: string,
+  now = Date.now(),
 ): TurnBlock[] {
   if (!delta) return blocks;
   const last = blocks[blocks.length - 1];
-  if (last && last.type === type) {
+  if (last && last.type === type && !last.sealed) {
     const next = blocks.slice();
-    next[next.length - 1] = { type, content: last.content + delta };
+    next[next.length - 1] =
+      last.type === 'reasoning'
+        ? { ...last, content: last.content + delta }
+        : { type, content: last.content + delta };
     return next;
   }
-  return [...blocks, { type, content: delta }];
+  const frozen = freezeReasoningDurations(blocks, now);
+  if (type === 'reasoning') {
+    return [...frozen, { type, content: delta, startedAtMs: now }];
+  }
+  return [...frozen, { type, content: delta }];
+}
+
+/**
+ * Close the current reasoning/text segment so the next same-kind delta
+ * starts a new block. Used at LLM-round boundaries (tool round finished,
+ * hook retry, auto-continue) — otherwise consecutive rounds concatenate
+ * into one wall of thought and hide the intermediate results between them.
+ */
+export function sealLastBlock(blocks: TurnBlock[], now = Date.now()): TurnBlock[] {
+  if (blocks.length === 0) return blocks;
+  const last = blocks[blocks.length - 1];
+  if (last.type === 'tools' || last.sealed) return blocks;
+  const next = blocks.slice();
+  next[next.length - 1] =
+    last.type === 'reasoning'
+      ? { ...freezeReasoningBlock(last, now), sealed: true }
+      : { ...last, sealed: true };
+  return next;
 }
 
 export function syncTools(
   blocks: TurnBlock[],
   actions: ExecutedAction[],
+  now = Date.now(),
 ): TurnBlock[] {
   let placed = 0;
   for (const block of blocks) {
     if (block.type === 'tools') placed += block.actions.length;
   }
 
-  const next: TurnBlock[] = blocks.map((block) =>
+  const next: TurnBlock[] = freezeReasoningDurations(blocks, now).map((block) =>
     block.type === 'tools' ? { type: 'tools', actions: [...block.actions] } : block,
   );
 
@@ -89,7 +168,25 @@ export function parseTurnBlocks(raw: unknown): TurnBlock[] | null {
     const rec = item as Record<string, unknown>;
     if (rec.type === 'text' || rec.type === 'reasoning') {
       if (typeof rec.content !== 'string') return null;
-      blocks.push({ type: rec.type, content: rec.content });
+      const block: TurnBlock =
+        rec.type === 'reasoning'
+          ? {
+              type: 'reasoning',
+              content: rec.content,
+              ...(rec.sealed === true ? { sealed: true } : {}),
+              ...(typeof rec.startedAtMs === 'number' && Number.isFinite(rec.startedAtMs)
+                ? { startedAtMs: rec.startedAtMs }
+                : {}),
+              ...(typeof rec.durationMs === 'number' && Number.isFinite(rec.durationMs)
+                ? { durationMs: rec.durationMs }
+                : {}),
+            }
+          : {
+              type: 'text',
+              content: rec.content,
+              ...(rec.sealed === true ? { sealed: true } : {}),
+            };
+      blocks.push(block);
       continue;
     }
     if (rec.type === 'tools') {
@@ -103,14 +200,21 @@ export function parseTurnBlocks(raw: unknown): TurnBlock[] | null {
 }
 
 /**
- * Trailing text is the final summary. Reasoning, tools, and any narration
- * that happened before that last answer stay in the foldable process group
- * (Codex / DeepSeek turn-process).
+ * Trailing text is the final conclusion — but only after the turn finishes.
+ * While streaming, every text block stays in the process as a post-think
+ * response so the next reasoning burst cannot restyle it as thinking.
  */
-export function splitTurnProcess(blocks: TurnBlock[]): {
+export function splitTurnProcess(
+  blocks: TurnBlock[],
+  options?: { finalize?: boolean },
+): {
   process: TurnBlock[];
   answer: Extract<TurnBlock, { type: 'text' }>[];
 } {
+  const finalize = options?.finalize ?? true;
+  if (!finalize) {
+    return { process: blocks, answer: [] };
+  }
   let split = blocks.length;
   while (split > 0 && blocks[split - 1].type === 'text') split -= 1;
   return {
@@ -127,6 +231,14 @@ export function countProcessTools(process: TurnBlock[]): number {
   return n;
 }
 
+export function countProcessReasoning(process: TurnBlock[]): number {
+  let n = 0;
+  for (const block of process) {
+    if (block.type === 'reasoning' && block.content.trim().length > 0) n += 1;
+  }
+  return n;
+}
+
 export function processHasReasoning(process: TurnBlock[]): boolean {
   return process.some((block) => block.type === 'reasoning' && block.content.trim().length > 0);
 }

package/src/components/settings/AgentsSettingsPanel.tsx

@@ -200,14 +200,14 @@ export function AgentsSettingsPanel({
   };
 
   return (
-    <div className="space-y-4">
+    <div className="space-y-3">
       <p className="text-[11px] text-agent-muted-foreground">
         自定义智能体会出现在输入框上方的专家选择器里。角色设定会作为对话的人设前言，
         勾选的技能与工具权限在每一轮真实生效。内置智能体可以改文案和能力，但不能删除。
       </p>
 
       {formOpen ? (
-        <div className="space-y-2.5 rounded-agent-md border border-agent-border/60 bg-agent-muted/30 p-3.5">
+        <div className="space-y-2 rounded-agent-md border border-agent-border/60 bg-agent-muted/30 p-2.5">
           <h4 className="text-xs font-semibold text-agent-foreground">
             {editingId ? '编辑智能体' : '新建智能体'}
           </h4>

package/src/components/settings/AppearanceSettingsPanel.tsx

@@ -14,13 +14,13 @@ export function AppearanceSettingsPanel() {
 
   return (
     <div
-      className="space-y-3 rounded-agent-md border border-agent-border bg-agent-card p-4"
+      className="space-y-2 rounded-agent-md border border-agent-border bg-agent-card p-2.5"
       data-testid="appearance-settings-panel"
     >
       <div>
-        <p className="text-sm font-medium text-agent-foreground">显示思考内容</p>
+        <p className="text-xs font-medium text-agent-foreground">显示思考内容</p>
         <p className="mt-1 text-xs leading-relaxed text-agent-muted-foreground">
-          {current?.hint} 状态行仍显示思考中、工具名、速度和用时。
+          {current?.hint} 这三档只控制思考正文，不影响工具卡片和工作行。工作行只显示「工作中」或结束后的次数与用时。
         </p>
       </div>
       <div

package/src/components/settings/DiagnoseSettingsPanel.tsx

@@ -27,7 +27,7 @@ export function DiagnoseSettingsPanel() {
   };
 
   return (
-    <div className="space-y-3 rounded-agent-md border border-agent-border bg-agent-card p-4">
+    <div className="space-y-2 rounded-agent-md border border-agent-border bg-agent-card p-2.5">
       <p className="text-xs text-agent-muted-foreground">
         诊断当前模型服务的网络连通性，包括 DNS 解析、TCP 连接、TLS 握手、HTTP 接口与对话补全。
         诊断在宿主进程内执行，会同时报告系统/环境代理配置。
@@ -60,7 +60,7 @@ export function DiagnoseSettingsPanel() {
 
       {result && (
         <div className="space-y-2">
-          <div className="flex items-center gap-2 text-sm">
+          <div className="flex items-center gap-2 text-xs">
             {result.ok ? (
               <span className="inline-flex items-center gap-1 text-agent-success">
                 <LuCircleCheck className="h-4 w-4" />

package/src/components/settings/InsightsSettingsPanel.tsx

@@ -68,14 +68,14 @@ export function InsightsConsentBanner() {
 
   return (
     <div
-      className="flex-shrink-0 border-t border-agent-border bg-agent-muted px-4 py-3"
+      className="flex-shrink-0 border-t border-agent-border bg-agent-muted px-2.5 py-2"
       data-testid="insights-consent-banner"
       role="region"
       aria-label="帮助改进产品同意"
     >
       <div className="flex items-center justify-between gap-3">
         <div className="min-w-0">
-          <p className="text-sm font-medium text-agent-foreground">帮助改进{BRAND_NAME}</p>
+          <p className="text-xs font-medium text-agent-foreground">帮助改进{BRAND_NAME}</p>
           <p className="mt-1 text-xs leading-relaxed text-agent-muted-foreground">
             同意上传数据到服务器，帮助改进产品。之后可在设置里更改。
           </p>
@@ -198,8 +198,8 @@ export function InsightsSettingsPanel() {
   const stats = data.stats ?? empty.stats!;
 
   return (
-    <div className="space-y-4" data-testid="insights-settings-panel">
-      <div className="rounded-agent-md border border-agent-border/60 bg-agent-muted/30 p-3.5 space-y-3">
+    <div className="space-y-3" data-testid="insights-settings-panel">
+      <div className="rounded-agent-md border border-agent-border/60 bg-agent-muted/30 p-2.5 space-y-2">
         <h4 className="flex items-center gap-1.5 text-xs font-semibold text-agent-foreground">
           <LuChartBar className="h-3.5 w-3.5 text-agent-muted-foreground" />
           帮助改进产品（行为 / 对话 / 用户信息 分开确认）