@autobest-ui/agent 1.0.8 → 1.0.11

package/plugins/autobest-delivery/mcp-server/src/runner.mjs

@@ -155,6 +155,7 @@ export async function runFeatureE2E({
   scenarioPath,
   baseUrl,
   outputDir,
+  apiMode,
   iteration = 1,
   timeoutMs = 300000,
   headed = false,
@@ -175,12 +176,14 @@ export async function runFeatureE2E({
   const scenarioBlockers = [];
   const consoleErrors = [];
   const networkFailures = [];
+  const apiCalls = [];
   const invokedScenes = new Set();
   let browser;
   let context;
   let page;
   let blockedPage;
   let metadata = {};
+  let apiTargets = [];
   let timeoutId;
   let traceStarted = false;
   let traceError;
@@ -197,11 +200,63 @@ export async function runFeatureE2E({
       throw new TypeError('冻结场景必须导出一个默认异步函数');
     }
     metadata = scenarioModule.metadata || {};
+    const apiModeSchemaVersion = metadata.apiModeSchemaVersion;
     const reportSchemaVersion = metadata.reportSchemaVersion;
+    const reportCaptureSchemaVersion = metadata.reportCaptureSchemaVersion;
+    if (apiModeSchemaVersion !== undefined && apiModeSchemaVersion !== 1) {
+      throw new TypeError('metadata.apiModeSchemaVersion 仅支持 1');
+    }
+    if (apiModeSchemaVersion === 1) {
+      if (!['real', 'mock'].includes(metadata.apiMode)) {
+        throw new TypeError('metadata.apiMode 必须是 real 或 mock');
+      }
+      if (!['real', 'mock'].includes(apiMode)) {
+        throw new TypeError('run_feature_e2e 必须显式传入 apiMode: real 或 mock');
+      }
+      if (apiMode !== metadata.apiMode) {
+        throw new TypeError(
+          `执行 API 模式 ${apiMode} 与冻结场景模式 ${metadata.apiMode} 不一致`
+        );
+      }
+      if (!Array.isArray(metadata.apiTargets) || metadata.apiTargets.length === 0) {
+        throw new TypeError('metadata.apiTargets 必须是非空数组');
+      }
+      const targetIds = new Set();
+      apiTargets = metadata.apiTargets.map(target => {
+        if (!target || typeof target.id !== 'string' || !/^[a-z0-9][a-z0-9._-]*$/.test(target.id)) {
+          throw new TypeError('apiTarget.id 必须是稳定的 ASCII ID');
+        }
+        if (targetIds.has(target.id)) {
+          throw new TypeError(`apiTarget.id 不得重复：${target.id}`);
+        }
+        targetIds.add(target.id);
+        if (typeof target.method !== 'string' || !/^[A-Z]+$/.test(target.method)) {
+          throw new TypeError(`apiTarget ${target.id} 的 method 必须是大写 HTTP 方法`);
+        }
+        if (
+          typeof target.pathname !== 'string' ||
+          !target.pathname.startsWith('/') ||
+          target.pathname.includes('?') ||
+          target.pathname.includes('#')
+        ) {
+          throw new TypeError(`apiTarget ${target.id} 的 pathname 必须是无查询参数的绝对路径`);
+        }
+        return {
+          id: target.id,
+          method: target.method,
+          pathname: target.pathname
+        };
+      });
+    } else if (apiMode !== undefined && !['real', 'mock'].includes(apiMode)) {
+      throw new TypeError('apiMode 仅支持 real 或 mock');
+    }
     const traceabilitySchemaVersion = metadata.traceabilitySchemaVersion;
     if (reportSchemaVersion !== undefined && reportSchemaVersion !== 1) {
       throw new TypeError('metadata.reportSchemaVersion 仅支持 1');
     }
+    if (reportCaptureSchemaVersion !== undefined && reportCaptureSchemaVersion !== 1) {
+      throw new TypeError('metadata.reportCaptureSchemaVersion 仅支持 1');
+    }
     if (traceabilitySchemaVersion !== undefined && traceabilitySchemaVersion !== 1) {
       throw new TypeError('metadata.traceabilitySchemaVersion 仅支持 1');
     }
@@ -227,6 +282,14 @@ export async function runFeatureE2E({
           throw new TypeError(`visualMapping 引用了未知需求 ID：${mapping.requirementId}`);
         }
       }
+      for (const mapping of metadata.reportCaptures || []) {
+        if (!mapping || typeof mapping.requirementId !== 'string') {
+          throw new TypeError('reportCapture 必须包含 requirementId');
+        }
+        if (!requirementIds.has(mapping.requirementId)) {
+          throw new TypeError(`reportCapture 引用了未知需求 ID：${mapping.requirementId}`);
+        }
+      }
     }
     if (reportSchemaVersion === 1) {
       for (const mapping of metadata.visualMappings || []) {
@@ -243,6 +306,43 @@ export async function runFeatureE2E({
         }
       }
     }
+    if (reportCaptureSchemaVersion === 1) {
+      if (!Array.isArray(metadata.reportCaptures) || metadata.reportCaptures.length === 0) {
+        throw new TypeError('metadata.reportCaptures 必须是非空数组');
+      }
+      const captureNames = new Set();
+      for (const mapping of metadata.reportCaptures) {
+        for (const field of [
+          'capture',
+          'scene',
+          'locator',
+          'reportModule',
+          'reportGroup',
+          'reportTitle',
+          'reportDevice'
+        ]) {
+          if (!mapping || typeof mapping[field] !== 'string' || !mapping[field].trim()) {
+            throw new TypeError(`reportCapture 必须包含非空字符串字段 ${field}`);
+          }
+        }
+        if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*\.png$/.test(mapping.capture)) {
+          throw new TypeError('reportCapture.capture 必须是简单的 PNG 文件名');
+        }
+        if (captureNames.has(mapping.capture)) {
+          throw new TypeError(`reportCapture.capture 不得重复：${mapping.capture}`);
+        }
+        captureNames.add(mapping.capture);
+        if (!['desktop', 'mobile'].includes(mapping.reportDevice)) {
+          throw new TypeError('reportCapture.reportDevice 必须是 desktop 或 mobile');
+        }
+        if (!/^[a-z0-9][a-z0-9._-]*$/.test(mapping.reportGroup)) {
+          throw new TypeError('reportCapture.reportGroup 必须是稳定的 ASCII ID');
+        }
+        if (Array.isArray(metadata.scenes) && !metadata.scenes.includes(mapping.scene)) {
+          throw new TypeError(`reportCapture 引用了未知 scene：${mapping.scene}`);
+        }
+      }
+    }
 
     browser = await chromium.launch({ headless: !headed });
     context = await browser.newContext();
@@ -261,6 +361,28 @@ export async function runFeatureE2E({
           error: request.failure()?.errorText || '未知请求失败'
         });
       });
+      currentPage.on('response', response => {
+        const request = response.request();
+        const requestUrl = new URL(response.url());
+        for (const target of apiTargets) {
+          if (request.method() === target.method && requestUrl.pathname === target.pathname) {
+            apiCalls.push({
+              targetId: target.id,
+              method: target.method,
+              origin: requestUrl.origin,
+              pathname: target.pathname,
+              status: response.status()
+            });
+          }
+        }
+      });
+      if (metadata.apiMode === 'real') {
+        const rejectInterception = async () => {
+          throw new TypeError('real API 模式禁止 route() 或 page.route() 请求拦截');
+        };
+        Object.defineProperty(currentPage, 'route', { value: rejectInterception });
+        Object.defineProperty(currentPage, 'routeFromHAR', { value: rejectInterception });
+      }
       return currentPage;
     };
     page = await createPage();
@@ -323,7 +445,12 @@ export async function runFeatureE2E({
       expect,
       check,
       scene,
-      route: (pattern, handler) => currentPage.route(pattern, handler),
+      route: (pattern, handler) => {
+        if (metadata.apiMode === 'real') {
+          throw new TypeError('real API 模式禁止 route() 请求拦截');
+        }
+        return currentPage.route(pattern, handler);
+      },
       capture,
       artifact,
       baseUrl,
@@ -399,6 +526,37 @@ export async function runFeatureE2E({
         throw new TypeError(`以下需求 ID 没有运行或视觉覆盖：${uncovered.join(', ')}`);
       }
     }
+    if (metadata.apiModeSchemaVersion === 1 && scenarioBlockers.length === 0) {
+      const observedTargets = new Set(apiCalls.map(call => call.targetId));
+      const missingTargets = apiTargets
+        .filter(target => !observedTargets.has(target.id))
+        .map(target => target.id);
+      if (missingTargets.length > 0) {
+        throw new TypeError(`以下声明 API 未产生响应证据：${missingTargets.join(', ')}`);
+      }
+    }
+    if (reportCaptureSchemaVersion === 1 && scenarioBlockers.length === 0) {
+      const declaredCaptures = new Set(metadata.reportCaptures.map(item => item.capture));
+      const actualCaptures = new Set(captures.map(item => path.basename(item)));
+      const missingCaptures = [...declaredCaptures].filter(name => !actualCaptures.has(name));
+      if (missingCaptures.length > 0) {
+        throw new TypeError(`以下报告截图未生成：${missingCaptures.join(', ')}`);
+      }
+      const captureGroups = new Set(metadata.reportCaptures.map(item => item.reportGroup));
+      const missingGroups = [...new Set(checks.map(item => item.reportGroup))]
+        .filter(group => group && !captureGroups.has(group));
+      if (missingGroups.length > 0) {
+        throw new TypeError(`以下报告功能组没有截图：${missingGroups.join(', ')}`);
+      }
+      const declaredEvidence = new Set([
+        ...declaredCaptures,
+        ...(metadata.visualMappings || []).map(item => item.capture)
+      ]);
+      const undeclaredCaptures = [...actualCaptures].filter(name => !declaredEvidence.has(name));
+      if (undeclaredCaptures.length > 0) {
+        throw new TypeError(`以下截图未在 metadata 中声明：${undeclaredCaptures.join(', ')}`);
+      }
+    }
     if (blockedPage && !blockedPage.isClosed()) {
       await blockedPage.bringToFront().catch(() => undefined);
       page = blockedPage;
@@ -412,6 +570,8 @@ export async function runFeatureE2E({
       scenarioPath: toEvidencePath(root, scenario),
       scenarioSha256: beforeHash,
       metadata,
+      apiMode: metadata.apiMode || null,
+      apiCalls,
       checks,
       captures,
       tracePath: toEvidencePath(root, tracePath),
@@ -432,6 +592,8 @@ export async function runFeatureE2E({
       scenarioPath: toEvidencePath(root, scenario),
       scenarioSha256: beforeHash,
       metadata,
+      apiMode: metadata.apiMode || null,
+      apiCalls,
       checks,
       captures,
       tracePath: traceStarted ? toEvidencePath(root, tracePath) : null,

package/plugins/autobest-delivery/mcp-server/src/server.mjs

@@ -9,6 +9,17 @@ import {
   resolveBlockedRun,
   runFeatureE2E
 } from './runner.mjs';
+import {
+  abortFastCheck,
+  captureFastCheck,
+  closeAllFastChecks,
+  fastBrowserAction,
+  fastBrowserCheck,
+  fastBrowserSnapshot,
+  finishFastCheck,
+  mockFastCheckRoute,
+  startFastCheck
+} from './fast-runner.mjs';
 
 const server = new McpServer(
   {
@@ -17,10 +28,164 @@ const server = new McpServer(
   },
   {
     instructions:
-      '调用 run_feature_e2e 前先调用 check_environment。headed 运行在 Blocked 时可保留浏览器，随后通过 resolve_blocked_run 记录人工决议并关闭会话。'
+      '调用 E2E 或快速浏览器工具前先调用 check_environment。run_feature_e2e 执行冻结场景；start_fast_check 提供不生成场景文件的交互式自测。'
   }
 );
 
+function jsonResult(result) {
+  return {
+    structuredContent: result,
+    content: [{ type: 'text', text: JSON.stringify(result) }]
+  };
+}
+
+server.registerTool(
+  'start_fast_check',
+  {
+    title: '启动快速 Playwright 自测',
+    description: '启动无需 E2E 场景文件的交互式浏览器会话，并在工作区内准备快速证据目录。',
+    inputSchema: {
+      workspaceRoot: z.string().min(1),
+      baseUrl: z.string().url(),
+      outputDir: z.string().min(1),
+      apiMode: z.enum(['real', 'mock', 'none']).default('none'),
+      iteration: z.number().int().positive().default(1),
+      headed: z.boolean().default(false),
+      viewport: z.object({
+        width: z.number().int().min(320).max(3840),
+        height: z.number().int().min(480).max(2160)
+      }).default({ width: 1400, height: 1000 }),
+      requirementIds: z.array(z.string().regex(/^REQ-[A-Z][A-Z0-9]{1,15}-\d{3}$/)).default([]),
+      sessionTtlMs: z.number().int().min(60000).max(3600000).default(3600000)
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+  },
+  async input => jsonResult(await startFastCheck(input))
+);
+
+server.registerTool(
+  'fast_browser_snapshot',
+  {
+    title: '读取快速自测页面',
+    description: '返回当前页面的 URL、标题和精简可访问性快照，供后续交互定位。',
+    inputSchema: {
+      sessionId: z.string().uuid(),
+      timeoutMs: z.number().int().min(1000).max(120000).default(10000)
+    },
+    annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true }
+  },
+  async input => jsonResult(await fastBrowserSnapshot(input))
+);
+
+server.registerTool(
+  'fast_browser_action',
+  {
+    title: '执行快速自测页面操作',
+    description: '在快速自测会话中执行导航、点击、填写、选择、按键、等待或视口切换。',
+    inputSchema: {
+      sessionId: z.string().uuid(),
+      action: z.enum(['navigate', 'click', 'fill', 'select', 'press', 'wait', 'viewport']),
+      locator: z.string().optional(),
+      value: z.string().optional(),
+      url: z.string().optional(),
+      width: z.number().int().min(320).max(3840).optional(),
+      height: z.number().int().min(480).max(2160).optional(),
+      timeoutMs: z.number().int().min(1000).max(120000).default(10000)
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+  },
+  async input => jsonResult(await fastBrowserAction(input))
+);
+
+server.registerTool(
+  'mock_fast_check_route',
+  {
+    title: '设置快速自测 Mock',
+    description: '仅在 mock 模式为指定 HTTP method 和 pathname 设置 JSON 响应。',
+    inputSchema: {
+      sessionId: z.string().uuid(),
+      method: z.string().regex(/^[A-Z]+$/).default('GET'),
+      pathname: z.string().startsWith('/'),
+      status: z.number().int().min(100).max(599).default(200),
+      body: z.unknown().default({})
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
+  },
+  async input => jsonResult(await mockFastCheckRoute(input))
+);
+
+const reportFields = {
+  requirementId: z.string().optional(),
+  reportModule: z.string().min(1),
+  reportGroup: z.string().regex(/^[a-z0-9][a-z0-9._-]*$/),
+  reportTitle: z.string().min(1),
+  reportMethod: z.string().min(1)
+};
+
+server.registerTool(
+  'fast_browser_check',
+  {
+    title: '记录快速自测检查',
+    description: '执行一个结构化页面检查并记录可供报告导出的检查证据。',
+    inputSchema: {
+      sessionId: z.string().uuid(),
+      id: z.string().regex(/^[a-z0-9][a-z0-9._-]*$/),
+      ...reportFields,
+      specSnippet: z.string().min(1),
+      expect: z.string().min(1),
+      checkType: z.enum(['visible', 'hidden', 'text', 'value', 'count', 'url', 'attribute', 'css']),
+      locator: z.string().optional(),
+      expected: z.string().optional(),
+      expectedNumber: z.number().int().nonnegative().optional(),
+      property: z.string().optional(),
+      exact: z.boolean().default(false),
+      timeoutMs: z.number().int().min(1000).max(120000).default(10000)
+    },
+    annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true }
+  },
+  async input => jsonResult(await fastBrowserCheck(input))
+);
+
+server.registerTool(
+  'capture_fast_check',
+  {
+    title: '保存快速自测报告截图',
+    description: '保存页面或组件 PNG，并记录功能分组和桌面端/移动端报告映射。',
+    inputSchema: {
+      sessionId: z.string().uuid(),
+      ...reportFields,
+      capture: z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]*\.png$/),
+      locator: z.string().optional(),
+      reportDevice: z.enum(['desktop', 'mobile']),
+      fullPage: z.boolean().default(true)
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+  },
+  async input => jsonResult(await captureFastCheck(input))
+);
+
+server.registerTool(
+  'finish_fast_check',
+  {
+    title: '完成快速 Playwright 自测',
+    description: '关闭会话并写入 fast-check-result.json、Markdown、Trace 和截图索引。',
+    inputSchema: { sessionId: z.string().uuid() },
+    annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
+  },
+  async input => jsonResult(await finishFastCheck(input))
+);
+
+server.registerTool(
+  'abort_fast_check',
+  {
+    title: '放弃快速 Playwright 自测',
+    description: '关闭快速自测浏览器且不生成完成证据。',
+    inputSchema: { sessionId: z.string().uuid() },
+    annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
+  },
+  async input => jsonResult(await abortFastCheck(input))
+);
+
 server.registerTool(
   'check_environment',
   {
@@ -61,12 +226,13 @@ server.registerTool(
   {
     title: '执行冻结的功能 E2E 场景',
     description:
-      '使用插件自带的 Playwright 运行器执行无依赖冻结场景；scene 隔离可在单个场景阻塞后继续执行其余场景，并在功能目录下写入结构化证据。',
+      '使用插件自带的 Playwright 运行器执行无依赖冻结场景；显式校验 real/mock API 模式，scene 隔离可在单个场景阻塞后继续执行其余场景，并在功能目录下写入结构化证据。',
     inputSchema: {
       workspaceRoot: z.string().min(1),
       scenarioPath: z.string().min(1),
       baseUrl: z.string().url(),
       outputDir: z.string().min(1),
+      apiMode: z.enum(['real', 'mock']).optional(),
       iteration: z.number().int().positive().default(1),
       timeoutMs: z.number().int().min(1000).max(900000).default(300000),
       headed: z.boolean().default(false),
@@ -79,6 +245,8 @@ server.registerTool(
       scenarioPath: z.string(),
       scenarioSha256: z.string().nullable(),
       metadata: z.record(z.string(), z.unknown()),
+      apiMode: z.enum(['real', 'mock']).nullable(),
+      apiCalls: z.array(z.record(z.string(), z.unknown())),
       checks: z.array(z.record(z.string(), z.unknown())),
       captures: z.array(z.string()),
       tracePath: z.string().nullable(),
@@ -119,6 +287,8 @@ server.registerTool(
         scenarioPath: input.scenarioPath,
         scenarioSha256: null,
         metadata: {},
+        apiMode: input.apiMode || null,
+        apiCalls: [],
         checks: [],
         captures: [],
         tracePath: null,
@@ -193,7 +363,7 @@ await server.connect(transport);
 
 for (const signal of ['SIGINT', 'SIGTERM']) {
   process.once(signal, async () => {
-    await closeAllBlockedRuns();
+    await Promise.all([closeAllBlockedRuns(), closeAllFastChecks()]);
     process.exit(0);
   });
 }

package/plugins/autobest-delivery/mcp-server/tests/fast-runner.test.mjs

@@ -0,0 +1,232 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import {
+  abortFastCheck,
+  activeFastCheckCount,
+  captureFastCheck,
+  fastBrowserAction,
+  fastBrowserCheck,
+  fastBrowserSnapshot,
+  finishFastCheck,
+  mockFastCheckRoute,
+  startFastCheck
+} from '../src/fast-runner.mjs';
+import { startFixtureServer } from './fixture-server.mjs';
+
+const report = {
+  reportModule: '交付测试页',
+  reportGroup: 'reveal-result',
+  reportTitle: '结果展示',
+  reportMethod: '通过交互式 Playwright 点击按钮并检查结果文案。'
+};
+
+test('交互式快速自测生成检查、截图、Trace 和结果文件，不生成场景代码', async t => {
+  const fixture = await startFixtureServer();
+  t.after(fixture.close);
+  const workspaceRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'autobest-fast-check-'));
+  t.after(() => fs.rm(workspaceRoot, { recursive: true, force: true }));
+
+  const started = await startFastCheck({
+    workspaceRoot,
+    baseUrl: fixture.baseUrl,
+    outputDir: 'feature/fast-check/runs/iteration-01',
+    iteration: 1
+  });
+  assert.equal(activeFastCheckCount(), 1);
+
+  const snapshot = await fastBrowserSnapshot({ sessionId: started.sessionId });
+  assert.match(snapshot.snapshot, /显示结果/);
+
+  const click = await fastBrowserAction({
+    sessionId: started.sessionId,
+    action: 'click',
+    locator: '#reveal'
+  });
+  assert.equal(click.success, true);
+
+  const checked = await fastBrowserCheck({
+    sessionId: started.sessionId,
+    id: 'story-01',
+    ...report,
+    specSnippet: '点击按钮后显示运行结果。',
+    expect: '结果区域显示“运行器运行正常”',
+    checkType: 'text',
+    locator: '#result',
+    expected: '运行器运行正常',
+    timeoutMs: 10000
+  });
+  assert.equal(checked.check.isPass, true);
+
+  const captured = await captureFastCheck({
+    sessionId: started.sessionId,
+    ...report,
+    capture: 'result-desktop.png',
+    locator: 'main',
+    reportDevice: 'desktop'
+  });
+  assert.match(captured.capture.path, /result-desktop\.png$/);
+
+  const result = await finishFastCheck({ sessionId: started.sessionId });
+  assert.equal(result.status, 'passed');
+  assert.equal(result.evidenceSource, 'interactive-playwright');
+  assert.equal(result.scenarioPath, null);
+  assert.equal(result.scenarioSha256, null);
+  assert.equal(result.checks.length, 1);
+  assert.equal(result.captureRecords.length, 1);
+  assert.equal(activeFastCheckCount(), 0);
+  await assert.rejects(
+    fastBrowserSnapshot({ sessionId: started.sessionId }),
+    /会话不存在或已结束/
+  );
+
+  const resultPath = path.join(workspaceRoot, result.resultPath);
+  const persisted = JSON.parse(await fs.readFile(resultPath, 'utf8'));
+  assert.equal(persisted.status, 'passed');
+  await fs.access(path.join(workspaceRoot, result.captureRecords[0].path));
+  await fs.access(path.join(workspaceRoot, result.tracePath));
+  await fs.access(path.join(workspaceRoot, result.markdownPath));
+  await assert.rejects(fs.access(path.join(workspaceRoot, 'feature', 'e2e', 'e2e.feature.mjs')));
+});
+
+test('快速自测失败会记录结果，会话也可以显式放弃', async t => {
+  const fixture = await startFixtureServer();
+  t.after(fixture.close);
+  const workspaceRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'autobest-fast-check-failed-'));
+  t.after(() => fs.rm(workspaceRoot, { recursive: true, force: true }));
+
+  const failedSession = await startFastCheck({
+    workspaceRoot,
+    baseUrl: fixture.baseUrl,
+    outputDir: 'feature/fast-check/runs/iteration-01'
+  });
+  await fastBrowserCheck({
+    sessionId: failedSession.sessionId,
+    id: 'story-01',
+    ...report,
+    specSnippet: '结果应立即显示。',
+    expect: '结果文案可见',
+    checkType: 'text',
+    locator: '#result',
+    expected: '不存在的结果',
+    timeoutMs: 1000
+  });
+  await captureFastCheck({
+    sessionId: failedSession.sessionId,
+    ...report,
+    capture: 'failed-desktop.png',
+    reportDevice: 'desktop'
+  });
+  assert.equal((await finishFastCheck({ sessionId: failedSession.sessionId })).status, 'failed');
+
+  const abortedSession = await startFastCheck({
+    workspaceRoot,
+    baseUrl: fixture.baseUrl,
+    outputDir: 'feature/fast-check/runs/iteration-02'
+  });
+  assert.deepEqual(await abortFastCheck({ sessionId: abortedSession.sessionId }), {
+    status: 'aborted',
+    sessionId: abortedSession.sessionId
+  });
+  assert.equal(activeFastCheckCount(), 0);
+});
+
+test('快速自测拒绝越界输出，且只有 mock 模式允许安装响应', async t => {
+  const fixture = await startFixtureServer();
+  t.after(fixture.close);
+  const workspaceRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'autobest-fast-check-policy-'));
+  t.after(() => fs.rm(workspaceRoot, { recursive: true, force: true }));
+
+  await assert.rejects(
+    startFastCheck({
+      workspaceRoot,
+      baseUrl: fixture.baseUrl,
+      outputDir: '../outside'
+    }),
+    /outputDir 必须位于 workspaceRoot 内/
+  );
+
+  const realSession = await startFastCheck({
+    workspaceRoot,
+    baseUrl: fixture.baseUrl,
+    outputDir: 'feature/fast-check/runs/iteration-01',
+    apiMode: 'real'
+  });
+  await assert.rejects(
+    mockFastCheckRoute({
+      sessionId: realSession.sessionId,
+      pathname: '/api/status'
+    }),
+    /只有 mock 模式可以安装请求响应/
+  );
+  await abortFastCheck({ sessionId: realSession.sessionId });
+
+  const mockSession = await startFastCheck({
+    workspaceRoot,
+    baseUrl: fixture.baseUrl,
+    outputDir: 'feature/fast-check/runs/iteration-02',
+    apiMode: 'mock'
+  });
+  assert.deepEqual(
+    await mockFastCheckRoute({
+      sessionId: mockSession.sessionId,
+      pathname: '/api/status',
+      body: { source: 'mock' }
+    }),
+    {
+      sessionId: mockSession.sessionId,
+      method: 'GET',
+      pathname: '/api/status',
+      status: 200,
+      success: true
+    }
+  );
+  await abortFastCheck({ sessionId: mockSession.sessionId });
+  assert.equal(activeFastCheckCount(), 0);
+});
+
+test('追踪需求或报告功能组缺少证据时快速自测不能通过', async t => {
+  const fixture = await startFixtureServer();
+  t.after(fixture.close);
+  const workspaceRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'autobest-fast-check-coverage-'));
+  t.after(() => fs.rm(workspaceRoot, { recursive: true, force: true }));
+
+  const started = await startFastCheck({
+    workspaceRoot,
+    baseUrl: fixture.baseUrl,
+    outputDir: 'feature/fast-check/runs/iteration-01',
+    requirementIds: ['REQ-PAGE-001', 'REQ-PAGE-002']
+  });
+  await fastBrowserCheck({
+    sessionId: started.sessionId,
+    id: 'req-page-001-heading',
+    requirementId: 'REQ-PAGE-001',
+    ...report,
+    reportGroup: 'page-heading',
+    reportTitle: '页面标题',
+    specSnippet: '页面显示标题。',
+    expect: '标题可见',
+    checkType: 'visible',
+    locator: 'h1'
+  });
+  await captureFastCheck({
+    sessionId: started.sessionId,
+    requirementId: 'REQ-PAGE-001',
+    ...report,
+    reportGroup: 'other-group',
+    capture: 'other-group-desktop.png',
+    reportDevice: 'desktop'
+  });
+
+  const result = await finishFastCheck({ sessionId: started.sessionId });
+  assert.equal(result.status, 'blocked');
+  assert.ok(result.blockers.some(blocker =>
+    blocker.kind === 'traceability' && blocker.detail.includes('REQ-PAGE-002')
+  ));
+  assert.ok(result.blockers.some(blocker =>
+    blocker.kind === 'report-capture' && blocker.detail.includes('page-heading')
+  ));
+});