feat(cli): 改善流式推理块渲染并精简安全报告输出

iammm0 · iammm0 · commit 484de676889f · 2026-04-05T14:54:12.000+08:00
- 后端 SSE 为推理/工具事件增加 step_key，并行子任务不再共用 iteration 导致时间线串台
- 摘要阶段输出结构化精炼「安全报告」，最终 response 改为短收尾避免与报告重复刷屏
- SummaryAgent 截断过长观察/思路传入 LLM，并约束报告篇幅与禁止粘贴大段原始数据
- TUI：thoughtChunks 按 step 索引；跳过空占位推理块；展示 report 块；report_generator 工具短时隐藏
- 推理正文改用默认前景色，避免 Windows 控制台 dim 不可读

Made-with: Cursor
diff --git a/server/src/modules/agents/core/summary-agent.ts b/server/src/modules/agents/core/summary-agent.ts
@@ -17,7 +17,17 @@ const SUMMARY_SYSTEM_PROMPT =
   '1. 语言简洁专业，使用中文。\n' +
   '2. 包含任务概述、关键发现、风险评估、修复建议和总结。\n' +
   '3. 关键发现需要按严重程度排序（高危 > 中危 > 低危 > 信息）。\n' +
-  '4. 修复建议要具体可操作，而非泛泛而谈。';
+  '4. 修复建议要具体可操作，而非泛泛而谈。\n' +
+  '5. 全文控制在约 600–1200 汉字；用要点归纳，禁止大段粘贴原始 JSON、进程列表或完整配置文件。';
+
+const MAX_THOUGHT_CHARS = 1_200;
+const MAX_OBS_CHARS = 2_500;
+
+function clipForSummary(text: string, maxChars: number): string {
+  const t = text.trim();
+  if (t.length <= maxChars) return t;
+  return `${t.slice(0, maxChars)}\n…（已截断，原文约 ${t.length} 字符）`;
+}
 
 export class SummaryAgent extends BaseAgent {
   private readonly llm: LLMProvider;
@@ -103,16 +113,23 @@ export class SummaryAgent extends BaseAgent {
     }
 
     if (options?.thoughts?.length) {
-      parts.push(`## 分析思路\n${options.thoughts.map((t, i) => `${i + 1}. ${t}`).join('\n')}`);
+      const lines = options.thoughts.map(
+        (t, i) => `${i + 1}. ${clipForSummary(t, MAX_THOUGHT_CHARS)}`,
+      );
+      parts.push(`## 分析思路\n${lines.join('\n')}`);
     }
 
     if (options?.observations?.length) {
-      parts.push(`## 观察结果\n${options.observations.map((o, i) => `${i + 1}. ${o}`).join('\n')}`);
+      const lines = options.observations.map(
+        (o, i) => `${i + 1}. ${clipForSummary(o, MAX_OBS_CHARS)}`,
+      );
+      parts.push(`## 观察结果\n${lines.join('\n')}`);
     }
 
     if (options?.toolResults?.length) {
       const toolLines = options.toolResults.map(
-        (r) => `- **${r.tool}**: ${r.success ? '成功' : '失败'} — ${r.result}`,
+        (r) =>
+          `- **${r.tool}**: ${r.success ? '成功' : '失败'} — ${clipForSummary(String(r.result ?? ''), MAX_OBS_CHARS)}`,
       );
       parts.push(`## 工具执行结果\n${toolLines.join('\n')}`);
     }
diff --git a/server/src/modules/chat/chat.service.ts b/server/src/modules/chat/chat.service.ts
@@ -28,6 +28,49 @@ import { TaskExecutor } from '../agents/core/task-executor';
 import { ChatRequestDto, ChatResponseDto } from './dto/chat.dto';
 import { ToolsService } from '../tools/tools.service';
 
+/** 与 SecurityReActAgent 中 THINK/EXEC 事件的 step 关联键一致，避免并行子任务共用 iteration 导致前端时间线串台 */
+function sseStepKey(data: Record<string, unknown>, iteration: number): string {
+  const todoId = data['todoId'];
+  if (todoId !== undefined && todoId !== null && String(todoId).length > 0) {
+    return `todo-${todoId}`;
+  }
+  return `iter-${iteration}`;
+}
+
+/** CLI 流式输出用：结构化精炼报告 + 较短最终回复，避免刷屏 */
+function buildStreamSummaryPayload(summary: InteractionSummary): {
+  report: string;
+  response: string;
+} {
+  const findings = summary.keyFindings
+    .slice(0, 6)
+    .map((l) => `- ${l}`)
+    .join('\n');
+  const recs = summary.recommendations
+    .slice(0, 6)
+    .map((l) => `- ${l}`)
+    .join('\n');
+  const parts: string[] = [];
+  const head = summary.taskSummary?.trim();
+  if (head) parts.push(`## 摘要\n${head}`);
+  if (findings) parts.push(`## 关键发现\n${findings}`);
+  if (recs) parts.push(`## 修复建议\n${recs}`);
+  const tail = summary.overallConclusion?.trim();
+  if (tail) parts.push(`## 总结\n${tail}`);
+  let report = parts.join('\n\n');
+  if (!report.trim()) {
+    report = summary.rawReport?.trim() ? summary.rawReport.slice(0, 12_000) : '（未能生成摘要，请查看服务端日志。）';
+  }
+  /** 短收尾：详细章节已在「安全报告」块中展示，避免 TUI 再打一屏重复摘要 */
+  const response =
+    tail ||
+    (summary.keyFindings[0]?.trim()
+      ? `首要发现：${summary.keyFindings[0].trim()}`
+      : '') ||
+    '详情见上方「安全报告」。';
+  return { report, response };
+}
+
 @Injectable()
 export class ChatService {
   private eventBus = new EventBus();
@@ -120,34 +163,44 @@ export class ChatService {
       const t = event.type;
       const d = event.data;
       if (t === EventType.THINK_START) {
-        emit('thought_start', { iteration: d['iteration'] ?? 1 });
+        const iteration = Number(d['iteration'] ?? 1);
+        emit('thought_start', {
+          iteration,
+          step_key: sseStepKey(d, iteration),
+          task: d['task'] as string | undefined,
+        });
       } else if (t === EventType.THINK_END) {
+        const iteration = Number(d['iteration'] ?? 1);
         emit('thought', {
           content: d['thought'] ?? '',
-          iteration: d['iteration'] ?? 1,
+          iteration,
+          step_key: sseStepKey(d, iteration),
         });
       } else if (t === EventType.EXEC_START) {
+        const iteration = Number(d['iteration'] ?? 1);
         emit('action_start', {
           tool: d['tool'] ?? '',
           params: d['params'] ?? {},
-          iteration: d['iteration'] ?? 1,
+          iteration,
+          step_key: sseStepKey(d, iteration),
         });
       } else if (t === EventType.EXEC_RESULT) {
+        const iteration = Number(d['iteration'] ?? 1);
         emit('action_result', {
           tool: d['tool'] ?? '',
           success: d['success'] ?? true,
           result: d['observation'] ?? '',
-          iteration: d['iteration'] ?? 1,
+          iteration,
+          step_key: sseStepKey(d, iteration),
         });
       }
     };
 
-    let response: string;
     if (planResult.todos.length > 1) {
       const executor = new TaskExecutor(planResult, selectedAgent, this.eventBus);
-      response = await executor.run(message, onAgentEvent);
+      await executor.run(message, onAgentEvent);
     } else {
-      response = await selectedAgent.process(message, { onEvent: onAgentEvent });
+      await selectedAgent.process(message, { onEvent: onAgentEvent });
     }
 
     emit('phase', { phase: 'summarizing', detail: '正在生成报告...' });
@@ -162,13 +215,12 @@ export class ChatService {
       mode: planResult.todos.length <= 1 ? 'brief' : 'full',
     });
 
-    if (summary.rawReport) {
-      emit('report', { content: summary.rawReport });
-    }
+    const streamPayload = buildStreamSummaryPayload(summary);
+    emit('report', { content: streamPayload.report });
 
-    emit('response', { content: response, agent: agentType });
+    emit('response', { content: streamPayload.response, agent: agentType });
     emit('done', {});
-    return response;
+    return streamPayload.response;
   }
 
   async chatSync(body: ChatRequestDto): Promise<ChatResponseDto> {
diff --git a/terminal-ui/src/components/blocks/ThoughtBlock.tsx b/terminal-ui/src/components/blocks/ThoughtBlock.tsx
@@ -33,15 +33,13 @@ export function ThoughtBlock({ title, body, noMargin }: ThoughtBlockProps) {
         </Text>
       ) : null}
 
-      {/* 正文：每行前缀 ┊，dim gray */}
+      {/* 正文：前缀弱化；正文用默认前景色，避免 Windows 控制台 dim+gray 几乎不可读 */}
       {lines.map((line, i) => (
         <Box key={i} flexDirection="row">
           <Text dimColor color={theme.textMuted}>
             {"┊ "}
           </Text>
-          <Text dimColor color={theme.textMuted}>
-            {line || " "}
-          </Text>
+          <Text color={theme.text}>{line || " "}</Text>
         </Box>
       ))}
     </Box>
diff --git a/terminal-ui/src/contentBlocks.ts b/terminal-ui/src/contentBlocks.ts
@@ -15,7 +15,14 @@ import type { ContentBlock } from "./types.js";
 const MAX_RESULT_LINES = 24;
 
 /** 完成后仅标识"完成"并随后消失、且不渲染其输出内容的工具 */
-const TRANSIENT_TOOLS = new Set<string>(["system_info", "network_analyze"]);
+const TRANSIENT_TOOLS = new Set<string>([
+  "system_info",
+  "network_analyze",
+  "report_generator",
+]);
+
+/** 安全报告块最大行数（略宽于工具结果，仍防止刷屏） */
+const MAX_REPORT_LINES = 48;
 
 // ─── 工具函数 ──────────────────────────────────────────────────────────────────
 
@@ -119,6 +126,7 @@ export function streamStateToBlocks(
     actions,
     error,
     timeline,
+    report,
   } = streamState;
 
   const dismissed = dismissedTransientTools ?? new Set<string>();
@@ -212,11 +220,16 @@ export function streamStateToBlocks(
     lineStart = lineEnd;
   }
 
-  // ── 时间线渲染（按事件发生顺序）───────────────────────────────────────────────
+  // ── 时间线渲染（按事件发生顺序）；final 排在精炼「安全报告」之后，顺序与 SSE 一致 ──
   if (timeline.length > 0) {
-    for (const item of timeline) {
+    const nonFinal = timeline.filter((x) => x.type !== "final");
+    const finals = timeline.filter((x) => x.type === "final");
+
+    for (const item of nonFinal) {
       if (item.type === "thought") {
-        const extracted = extractThoughtOnly(item.body || "…");
+        const extracted = extractThoughtOnly(item.body || "");
+        const trimmed = extracted.trim();
+        if (!trimmed || trimmed === "…") continue;
         addBlock(
           item.id,
           "thought",
@@ -259,7 +272,18 @@ export function streamStateToBlocks(
         );
         continue;
       }
+    }
+
+    if (report?.trim()) {
+      addBlock(
+        "stream-report",
+        "report",
+        "安全报告",
+        truncateBody(report.trim(), MAX_REPORT_LINES),
+      );
+    }
 
+    for (const item of finals) {
       if (item.type === "final") {
         addBlock(
           item.id,
@@ -276,6 +300,14 @@ export function streamStateToBlocks(
     }
   } else {
     // 兼容旧结构：无 timeline 时退回到 content。
+    if (report?.trim()) {
+      addBlock(
+        "stream-report",
+        "report",
+        "安全报告",
+        truncateBody(report.trim(), MAX_REPORT_LINES),
+      );
+    }
     if (actions.length > 0) {
       const filtered = actions.filter(
         (a) => !TRANSIENT_TOOLS.has(a.tool) || !dismissed.has(a.tool),
diff --git a/terminal-ui/src/types.ts b/terminal-ui/src/types.ts
@@ -41,7 +41,8 @@ export interface StreamState {
     todos: Array<{ content: string; status?: string }>;
   } | null;
   thought: { iteration: number; content: string } | null;
-  thoughtChunks: Map<number, string>;
+  /** 推理流分片正文，键为后端 step_key（或 iter-N），避免并行子任务 iteration 重复时覆盖 */
+  thoughtChunks: Map<string, string>;
   actions: Array<{
     tool: string;
     params: Record<string, unknown>;
diff --git a/terminal-ui/src/useChat.ts b/terminal-ui/src/useChat.ts
@@ -99,7 +99,8 @@ export function useChat() {
   /** Typewriter 定时器，新消息到来时需要清理上一个 */
   const typewriterRef = useRef<ReturnType<typeof setInterval> | null>(null);
   const thoughtSeqRef = useRef<number>(0);
-  const activeThoughtIdByIterationRef = useRef<Map<number, string>>(new Map());
+  /** 按 step_key（子任务 todo / ReAct 轮次）关联推理时间线项，避免并行子任务共用 iteration 时串台 */
+  const activeThoughtIdByStepRef = useRef<Map<string, string>>(new Map());
 
   useEffect(() => {
     streamStateRef.current = streamState;
@@ -213,7 +214,7 @@ export function useChat() {
       currentSentAtRef.current = now;
       completedAtRef.current = 0;
       thoughtSeqRef.current = 0;
-      activeThoughtIdByIterationRef.current = new Map();
+      activeThoughtIdByStepRef.current = new Map();
 
       setCurrentUserMessage(message);
       setCurrentSentAt(now);
@@ -254,13 +255,15 @@ export function useChat() {
               case "thought_start":
                 setStreamState((s) => ({
                   ...(function () {
-                    const it = (data.iteration as number) ?? 1;
+                    const it = Number(data.iteration ?? 1);
+                    const stepKey =
+                      (data.step_key as string) || `iter-${it}`;
                     thoughtSeqRef.current += 1;
-                    const thoughtId = `thought-${it}-${thoughtSeqRef.current}`;
-                    activeThoughtIdByIterationRef.current.set(it, thoughtId);
+                    const thoughtId = `thought-${stepKey}-${thoughtSeqRef.current}`;
+                    activeThoughtIdByStepRef.current.set(stepKey, thoughtId);
                     const nextThoughtChunks = new Map(s.thoughtChunks);
-                    // 新一轮相同 iteration 的推理开始时，重置该 iteration 的分片缓存，避免串台
-                    nextThoughtChunks.set(it, "");
+                    // 新一轮相同 step 的推理开始时，重置该 step 的分片缓存，避免串台
+                    nextThoughtChunks.set(stepKey, "");
                     return {
                       ...s,
                       thought: {
@@ -282,14 +285,17 @@ export function useChat() {
                 break;
 
               case "thought_chunk": {
-                const it = (data.iteration as number) ?? 1;
+                const it = Number(data.iteration ?? 1);
+                const stepKey =
+                  (data.step_key as string) || `iter-${it}`;
                 const chunk = (data.chunk as string) ?? "";
                 const thoughtId =
-                  activeThoughtIdByIterationRef.current.get(it) ?? `thought-${it}`;
+                  activeThoughtIdByStepRef.current.get(stepKey) ??
+                  `thought-${stepKey}`;
                 setStreamState((s) => {
                   const next = new Map(s.thoughtChunks);
-                  next.set(it, (next.get(it) ?? "") + chunk);
-                  const thoughtBody = next.get(it) ?? "";
+                  next.set(stepKey, (next.get(stepKey) ?? "") + chunk);
+                  const thoughtBody = next.get(stepKey) ?? "";
                   return {
                     ...s,
                     thoughtChunks: next,
@@ -311,10 +317,12 @@ export function useChat() {
               }
 
               case "thought": {
-                const tIt = (data.iteration as number) ?? 1;
+                const tIt = Number(data.iteration ?? 1);
+                const stepKey =
+                  (data.step_key as string) || `iter-${tIt}`;
                 const tId =
-                  activeThoughtIdByIterationRef.current.get(tIt) ??
-                  `thought-${tIt}`;
+                  activeThoughtIdByStepRef.current.get(stepKey) ??
+                  `thought-${stepKey}`;
                 setStreamState((s) => {
                   const existing = s.timeline.find((t) => t.id === tId);
                   if (existing?.status === "done") return s;
@@ -334,15 +342,15 @@ export function useChat() {
                         body:
                           (data.content as string) ??
                           prev?.body ??
-                          s.thoughtChunks.get(tIt) ??
+                          s.thoughtChunks.get(stepKey) ??
                           "",
                         iteration: tIt,
                         status: "done",
                       }),
                     ),
                   };
                 });
-                activeThoughtIdByIterationRef.current.delete(tIt);
+                activeThoughtIdByStepRef.current.delete(stepKey);
                 break;
               }
 
