feat(benchmark): 添加真实仓库基准测试工具和更详细的无头事件

- 新增真实仓库基准测试工具，包含三类固定任务（分析、窄范围修复、跨模块修复）
- 增强无头事件协议，添加阶段事件以区分搜索、检查、目标命中等状态
- 改进工具事件，包含目标路径和工具类型信息
- 更新确认提示组件，根据规划模式和最大轮次调整快捷键提示
- 添加基准测试相关脚本和测试覆盖
- 修复类型安全问题和测试中的生成器函数

Author: echoVic

.gitignore

@@ -71,6 +71,7 @@ blade-context/
 
 # Local settings
 .blade/settings.local.json
+.blade/benchmarks/
 .claude/settings.local.json
 
 # Monorepo - 各包的构建输出

packages/cli/package.json

@@ -29,6 +29,7 @@
     "test:security": "node scripts/test.js security",
     "test:coverage": "node scripts/test.js all --coverage",
     "test:watch": "vitest --watch --config vitest.config.ts",
+    "benchmark:repo": "node scripts/run-bun.js run scripts/run-real-repo-benchmark.ts",
     "test:update-snapshots": "node scripts/test.js snapshot --update",
     "lint": "biome lint src tests",
     "lint:fix": "biome lint --write src tests",

packages/cli/scripts/run-real-repo-benchmark.ts

@@ -0,0 +1,44 @@
+import {
+  DEFAULT_REAL_REPO_BENCHMARK_CASES,
+  runRealRepoBenchmark,
+} from '../src/commands/headlessBenchmark.js';
+
+function getArgValue(flag: string): string | undefined {
+  const index = process.argv.indexOf(flag);
+  if (index === -1) return undefined;
+  return process.argv[index + 1];
+}
+
+async function main() {
+  const model = getArgValue('--model');
+  const historyPath = getArgValue('--history-path');
+  const result = await runRealRepoBenchmark({ model, historyPath });
+
+  console.log('Real repo benchmark completed.');
+  console.log(`History: ${result.historyPath}`);
+  for (const benchmarkCase of result.results) {
+    console.log(
+      [
+        `${benchmarkCase.label}`,
+        `success=${benchmarkCase.success}`,
+        `duration_ms=${benchmarkCase.durationMs.toFixed(1)}`,
+        `tokens=${benchmarkCase.totalTokens}`,
+        `read_files=${benchmarkCase.readFilesCount}`,
+        `blind_search=${benchmarkCase.blindSearchEvents}`,
+        `target_hit=${benchmarkCase.targetHitEvents}`,
+      ].join(' | ')
+    );
+  }
+  console.log(
+    [
+      'summary',
+      `success_rate=${(result.summary.successRate * 100).toFixed(1)}%`,
+      `avg_duration_ms=${result.summary.averageDurationMs.toFixed(1)}`,
+      `avg_tokens=${result.summary.averageTotalTokens.toFixed(1)}`,
+      `avg_read_files=${result.summary.averageReadFilesCount.toFixed(1)}`,
+      `cases=${DEFAULT_REAL_REPO_BENCHMARK_CASES.length}`,
+    ].join(' | ')
+  );
+}
+
+void main();

packages/cli/src/agent/loop/StreamingToolExecutor.ts

@@ -50,8 +50,11 @@ function combineAbortSignals(...signals: AbortSignal[]): AbortSignal {
   if (validSignals.length === 1) return validSignals[0];
 
   // Use AbortSignal.any if available (Node 20+)
-  if ('any' in AbortSignal && typeof (AbortSignal as any).any === 'function') {
-    return (AbortSignal as any).any(validSignals);
+  const abortSignalWithAny = AbortSignal as typeof AbortSignal & {
+    any?: (signals: AbortSignal[]) => AbortSignal;
+  };
+  if (typeof abortSignalWithAny.any === 'function') {
+    return abortSignalWithAny.any(validSignals);
   }
   // Fallback: manual composite
   for (const s of validSignals) {
@@ -356,4 +359,4 @@ export class StreamingToolExecutor {
       this.activeAborts.delete(toolCall.id);
     }
   }
-}
+}

packages/cli/src/commands/headless.ts

@@ -104,6 +104,25 @@ interface HeadlessStreamSnapshot {
   wroteAssistantContent: boolean;
 }
 
+interface HeadlessPhaseContext {
+  turn?: number;
+  toolName?: string;
+  target?: string;
+}
+
+type HeadlessPhaseName =
+  | 'turn'
+  | 'searching'
+  | 'inspecting'
+  | 'target_hit'
+  | 'executing'
+  | 'completed';
+type HeadlessPhaseStatus = 'ongoing' | 'hit' | 'done';
+
+interface HeadlessPhaseState {
+  targetLocked: boolean;
+}
+
 class HeadlessStreamState {
   private openedThinking = false;
   private wroteAssistantContent = false;
@@ -245,6 +264,113 @@ function resolveOutputFormat(outputFormat?: string): HeadlessOutputFormat {
   return outputFormat === 'jsonl' ? 'jsonl' : 'text';
 }
 
+function extractToolTarget(
+  toolName: string,
+  params: Record<string, unknown>
+): string | undefined {
+  const stringParam = (...keys: string[]) => {
+    for (const key of keys) {
+      const value = params[key];
+      if (typeof value === 'string' && value.trim() !== '') {
+        return value;
+      }
+    }
+    return undefined;
+  };
+
+  switch (toolName) {
+    case 'Read':
+    case 'Edit':
+    case 'Write':
+    case 'UndoEdit':
+      return stringParam('file_path');
+    case 'NotebookEdit':
+      return stringParam('notebook_path');
+    case 'Grep':
+      return stringParam('path', 'pattern');
+    case 'Glob':
+      return stringParam('pattern');
+    case 'WebFetch':
+      return stringParam('url');
+    case 'WebSearch':
+      return stringParam('query');
+    case 'Bash':
+      return stringParam('description', 'command');
+    case 'Task':
+      return stringParam('description');
+    case 'LSP':
+      return stringParam('filePath', 'operation');
+    default:
+      return undefined;
+  }
+}
+
+function getPhaseForTool(
+  toolName: string,
+  summary: string,
+  target: string | undefined,
+  state: HeadlessPhaseState
+): {
+  phase: HeadlessPhaseName;
+  status: HeadlessPhaseStatus;
+  message: string;
+  shouldLockTarget: boolean;
+} {
+  const searchTools = new Set(['Glob', 'Grep', 'WebSearch', 'LS']);
+  const readTools = new Set(['Read', 'WebFetch']);
+  const actionTools = new Set([
+    'Edit',
+    'Write',
+    'NotebookEdit',
+    'Bash',
+    'LSP',
+    'UndoEdit',
+  ]);
+
+  if (actionTools.has(toolName) && !state.targetLocked) {
+    return {
+      phase: 'target_hit',
+      status: 'hit',
+      message: `Target locked: ${summary}`,
+      shouldLockTarget: true,
+    };
+  }
+
+  if (state.targetLocked) {
+    return {
+      phase: 'executing',
+      status: 'hit',
+      message: target ? `Working within target: ${summary}` : `Executing: ${summary}`,
+      shouldLockTarget: false,
+    };
+  }
+
+  if (searchTools.has(toolName)) {
+    return {
+      phase: 'searching',
+      status: 'ongoing',
+      message: `Still searching: ${summary}`,
+      shouldLockTarget: false,
+    };
+  }
+
+  if (readTools.has(toolName)) {
+    return {
+      phase: 'inspecting',
+      status: 'ongoing',
+      message: `Inspecting candidate: ${summary}`,
+      shouldLockTarget: false,
+    };
+  }
+
+  return {
+    phase: 'executing',
+    status: state.targetLocked ? 'hit' : 'ongoing',
+    message: `Executing: ${summary}`,
+    shouldLockTarget: false,
+  };
+}
+
 function createEventWriter(
   io: HeadlessIO,
   outputFormat: HeadlessOutputFormat
@@ -303,20 +429,59 @@ function createEventWriter(
       }
       writeLine(io.stdout, content);
     },
-    toolStart(toolName: string, summary: string) {
+    toolStart(
+      toolName: string,
+      summary: string,
+      target?: string,
+      toolKind?: 'readonly' | 'write' | 'execute'
+    ) {
       if (outputFormat === 'jsonl') {
-        writeJsonl('tool_start', { tool_name: toolName, summary });
+        writeJsonl('tool_start', {
+          tool_name: toolName,
+          summary,
+          target,
+          tool_kind: toolKind,
+        });
         return;
       }
       writeLine(io.stderr, `[tool:start] ${summary}`);
     },
-    toolResult(toolName: string, summary: string) {
+    toolResult(
+      toolName: string,
+      summary: string,
+      target?: string,
+      toolKind?: 'readonly' | 'write' | 'execute'
+    ) {
       if (outputFormat === 'jsonl') {
-        writeJsonl('tool_result', { tool_name: toolName, summary });
+        writeJsonl('tool_result', {
+          tool_name: toolName,
+          summary,
+          target,
+          tool_kind: toolKind,
+        });
         return;
       }
       writeLine(io.stderr, `[tool:result] ${summary}`);
     },
+    phase(
+      phase: HeadlessPhaseName,
+      status: HeadlessPhaseStatus,
+      message: string,
+      context: HeadlessPhaseContext = {}
+    ) {
+      if (outputFormat === 'jsonl') {
+        writeJsonl('phase', {
+          phase,
+          status,
+          message,
+          turn: context.turn,
+          tool_name: context.toolName,
+          target: context.target,
+        });
+        return;
+      }
+      writeLine(io.stderr, `[phase:${phase}] ${message}`);
+    },
     toolDetail(toolName: string, detail: string) {
       if (outputFormat === 'jsonl') {
         writeJsonl('tool_detail', { tool_name: toolName, detail });
@@ -399,6 +564,7 @@ export async function runHeadless(
   let outputFormat: HeadlessOutputFormat = 'text';
   let eventWriter = createEventWriter(io, outputFormat);
   const streamState = new HeadlessStreamState();
+  const phaseState: HeadlessPhaseState = { targetLocked: false };
 
   try {
     const validatedOptions = validateHeadlessOptions(options);
@@ -481,17 +647,61 @@ export async function runHeadless(
             try {
               const params = JSON.parse(toolCall.function.arguments);
               const summary = formatToolCallSummary(toolCall.function.name, params);
-              eventWriter.toolStart(toolCall.function.name, summary);
+              const target = extractToolTarget(toolCall.function.name, params);
+              const phaseInfo = getPhaseForTool(
+                toolCall.function.name,
+                summary,
+                target,
+                phaseState
+              );
+              if (phaseInfo.shouldLockTarget) {
+                phaseState.targetLocked = true;
+              }
+              eventWriter.phase(phaseInfo.phase, phaseInfo.status, phaseInfo.message, {
+                toolName: toolCall.function.name,
+                target,
+              });
+              eventWriter.toolStart(
+                toolCall.function.name,
+                summary,
+                target,
+                event.toolKind
+              );
             } catch {
-              eventWriter.toolStart(toolCall.function.name, toolCall.function.name);
+              eventWriter.phase(
+                phaseState.targetLocked ? 'executing' : 'searching',
+                phaseState.targetLocked ? 'hit' : 'ongoing',
+                phaseState.targetLocked
+                  ? `Working within target: ${toolCall.function.name}`
+                  : `Still searching: ${toolCall.function.name}`,
+                { toolName: toolCall.function.name }
+              );
+              eventWriter.toolStart(
+                toolCall.function.name,
+                toolCall.function.name,
+                undefined,
+                event.toolKind
+              );
             }
             break;
           }
           case 'tool_result': {
             const toolCall = event.toolCall;
             if (!('function' in toolCall)) break;
+            let target: string | undefined;
+            try {
+              const params = JSON.parse(toolCall.function.arguments);
+              target = extractToolTarget(toolCall.function.name, params);
+            } catch {
+              target = undefined;
+            }
             const display = formatToolDisplay(toolCall.function.name, event.result);
-            eventWriter.toolResult(toolCall.function.name, display.summary);
+            eventWriter.toolResult(
+              toolCall.function.name,
+              display.summary,
+              target,
+              undefined
+            );
             if (display.detail) {
               eventWriter.toolDetail(toolCall.function.name, display.detail);
             }
@@ -520,6 +730,15 @@ export async function runHeadless(
 
           // --- 系统事件 ---
           case 'turn_start':
+            if (event.turn === 1) {
+              phaseState.targetLocked = false;
+            }
+            eventWriter.phase(
+              'turn',
+              phaseState.targetLocked ? 'hit' : 'ongoing',
+              `Turn ${event.turn} started`,
+              { turn: event.turn }
+            );
             break;
 
           default: {
@@ -537,6 +756,8 @@ export async function runHeadless(
       );
     }
 
+    eventWriter.phase('completed', 'done', 'Headless run completed');
+
     return 0;
   } catch (error) {
     if (streamState.hasOpenThinking() && outputFormat === 'text') {