@autobest-ui/agent 1.0.10 → 1.0.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autobest-ui/agent",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "private": false,
   "description": "Autobest Agent skills/plugins/mcp assets + sync cli",
   "files": [
@@ -19,6 +19,7 @@
     "autobest-agent-sync": "./bin/sync-assets.mjs",
     "autobest-code-mcp-pr": "./mcp/code-mcp-pr/index.js",
     "autobest-azurepr-mcp": "./mcp/azurepr-mcp-bridge/index.js",
+    "autobest-trace-mcp-recorder": "./mcp/trace-mcp-recorder/index.js",
     "autobest-delivery-setup": "./plugins/autobest-delivery/scripts/setup.mjs",
     "autobest-rag-mcp": "./mcp/rag-mcp-bridge/index.js",
     "figma-mcp-bridge": "./mcp/figma-mcp-bridge/src/index.js",
@@ -29,20 +30,26 @@
     "mcp:code-mcp-pr": "node ./mcp/code-mcp-pr/index.js",
     "mcp:figma": "node ./mcp/figma-mcp-bridge/src/index.js",
     "mcp:rag": "node ./mcp/rag-mcp-bridge/index.js",
+    "mcp:trace-recorder": "node ./mcp/trace-mcp-recorder/index.js",
     "test": "npm run test:skills && npm run test:mcp && npm run test:plugin",
     "test:skills": "node --test ./bin/sync-assets.test.mjs ./bin/traceability-validators.test.mjs",
     "test:mcp:azurepr": "node --test ./mcp/azurepr-mcp-bridge/index.test.js",
     "test:mcp:code-mcp-pr": "node --test ./mcp/code-mcp-pr/index.test.js",
     "test:mcp:figma": "node --test ./mcp/figma-mcp-bridge/index.test.js",
     "test:mcp:rag": "node --test ./mcp/rag-mcp-bridge/index.test.js",
-    "test:mcp": "npm run test:mcp:azurepr && npm run test:mcp:code-mcp-pr && npm run test:mcp:figma && npm run test:mcp:rag",
+    "test:mcp:trace-recorder": "node --test ./mcp/trace-mcp-recorder/index.test.js",
+    "test:mcp": "npm run test:mcp:azurepr && npm run test:mcp:code-mcp-pr && npm run test:mcp:figma && npm run test:mcp:rag && npm run test:mcp:trace-recorder",
     "test:plugin": "node --test ./plugins/autobest-delivery/scripts/setup.test.mjs ./plugins/figma-plugin/scripts/setup.test.mjs"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.30.0",
+    "axios": "1.20.0",
     "diff": "9.0.0",
+    "form-data": "4.0.6",
     "fs-extra": "11.3.0",
     "mdast-util-from-markdown": "2.0.2",
+    "playwright": "1.63.0",
+    "uuid": "14.0.2",
     "ws": "8.18.3",
     "zod": "4.4.3"
   },

package/plugins/autobest-delivery/.codex-plugin/plugin.json

@@ -18,6 +18,7 @@
     ],
     "defaultPrompt": [
       "\u9488\u5bf9\u5f53\u524d\u529f\u80fd\u89c4\u683c\u8fd0\u884c\u5b8c\u6574\u4ea4\u4ed8\u95ed\u73af\u3002",
+      "\u4f7f\u7528\u5feb\u901f\u4ea4\u4ed8\u95ed\u73af\u5b9e\u73b0\u5f53\u524d\u529f\u80fd\uff0c\u5b8c\u6210\u4ea4\u4e92\u5f0f Playwright \u81ea\u6d4b\u3001\u622a\u56fe\u548c\u72ec\u7acb\u4ee3\u7801\u5ba1\u8ba1\u3002",
       "\u68c0\u67e5\u9694\u79bb E2E \u8fd0\u884c\u5668\u662f\u5426\u5df2\u7ecf\u5c31\u7eea\u3002"
     ]
   },

package/plugins/autobest-delivery/README.md

@@ -1,12 +1,12 @@
 # Autobest 交付插件
 
-`autobest-delivery` 将 Autobest 交付闭环 Skill 与插件自带的 Playwright MCP 运行器打包在一起。目标业务仓库只需提供应用源码、功能规格和启动命令，不需要安装 Playwright 依赖。
+`autobest-delivery` 将 Autobest 完整及快速交付闭环 Skill 与插件自带的 Playwright MCP 运行器打包在一起。目标业务仓库只需提供应用源码、功能规格和启动命令，不需要安装 Playwright 依赖。
 
 ## 隔离机制
 
-运行器的 Node 依赖位于 `mcp-server/node_modules/`，Chromium 位于 `mcp-server/.runtime/ms-playwright/`，这两个路径均被插件忽略。工具只接受绝对路径形式的目标工作区，并且仅允许读取冻结场景、向指定功能输出目录写入证据。
+运行器的 Node 依赖位于 `mcp-server/node_modules/`，Chromium 位于 `mcp-server/.runtime/ms-playwright/`，这两个路径均被插件忽略。工具只接受绝对路径形式的目标工作区，并且仅允许读取所需输入、向工作区内指定功能输出目录写入证据。标准运行器会额外校验冻结场景在执行前后的 SHA-256。
 
-运行器不会在目标工作区调用包管理器，也不会修改目标仓库的清单、锁文件、`node_modules`、配置或源码。每次执行前后都会校验冻结场景的 SHA-256。
+运行器不会在目标工作区调用包管理器，也不会修改目标仓库的清单、锁文件、`node_modules`、配置或源码。标准 `run_feature_e2e` 每次执行前后都会校验冻结场景的 SHA-256。
 
 ## 使用 npx 安装
 
@@ -71,6 +71,21 @@ npx --yes --package=@autobest-ui/agent@latest autobest-delivery-setup --help
 
 新版场景通过 `scene(id, callback)` 隔离页面和执行错误。一个 scene 的定位器、弹窗或准备步骤阻塞时，运行器会记录该 blocker 并继续执行后续独立 scene，全部 scene 尝试结束后再返回 `blocked`。旧版直接使用顶层 `page` 的场景仍可运行，但无法在未捕获异常后继续。
 
+### 快速交互式 Playwright 工具
+
+`$delivery-loop-fast` 使用以下工具直接操作浏览器，不创建或执行 `e2e/e2e.feature.mjs`：
+
+- `start_fast_check`：启动会话并导航到应用；API 模式支持 `real`、`mock` 和无需业务 API 证明的 `none`。
+- `fast_browser_snapshot`：读取当前页面的可访问性快照。
+- `fast_browser_action`：执行导航、点击、填写、选择、按键、等待和视口切换。
+- `mock_fast_check_route`：仅在 `mock` 模式安装受控 JSON 响应。
+- `fast_browser_check`：执行并记录结构化页面检查。
+- `capture_fast_check`：保存按报告功能组映射的桌面端或移动端截图。
+- `finish_fast_check`：写入结果 JSON、中文 Markdown、Trace 和截图索引后关闭会话。
+- `abort_fast_check`：放弃未完成的会话并关闭浏览器。
+
+每轮产物位于 `fast-check/runs/iteration-NN/`，并以 `evidenceSource: interactive-playwright` 明确标识为实现者交互式自测，不属于独立 Checker 证据。后续 `$export-report` 可直接读取最新快速结果和截图。
+
 ### `resolve_blocked_run`
 
 用户查看 Blocked 浏览器后，由创建该会话的验收代理调用此工具。工具将选择写入 `human-decision.json` 并关闭浏览器；`accept` 或 `skip` 会形成 waiver，而不是伪装成完整通过。
@@ -144,7 +159,7 @@ export default async function run({
 
 Checker 和代码审计生成的 Markdown 使用简体中文，包括标题、摘要、表头、检查说明、期望、实际结果和 finding。JSON 字段名、机器状态、ID、路径及原始工具错误保持协议格式；英文原始错误旁提供中文解释。
 
-手动调用 `$export-report` 时，Excel 只生成一个 `自测报告` 工作表。每行代表一个真实 UI 组件或完整业务功能；同一组件或功能的文案、样式、布局、响应式行为和相关检查合并到同一行，桌面端与移动端代表截图也放在该行。报告不展示 REQ/story ID、scene 名或原子检查明细。新证据通过 `reportModule`、`reportGroup`、`reportTitle`、`reportMethod` 和 `reportDevice` 提供通用分组，并通过 `reportCaptures` 留下运行时 UI 截图。`visualMappings` 只负责有 Figma 基准时的视觉一致性验收；普通报告截图不表示视觉比对通过。旧证据必须由导出 Skill 分析 `spec.md` 后生成经过哈希和完整覆盖校验的语义分组清单，禁止按 E2E scene 猜测。
+手动调用 `$export-report` 时，Excel 可读取标准 Runner/Checker 证据或快速交互式自测证据，并且只生成一个 `自测报告` 工作表。每行代表一个真实 UI 组件或完整业务功能；同一组件或功能的文案、样式、布局、响应式行为和相关检查合并到同一行，桌面端与移动端代表截图也放在该行。报告不展示 REQ/story ID、scene 名或原子检查明细。新证据通过 `reportModule`、`reportGroup`、`reportTitle`、`reportMethod` 和 `reportDevice` 提供通用分组，并通过 `reportCaptures` 留下运行时 UI 截图。`visualMappings` 只负责有 Figma 基准时的视觉一致性验收；普通报告截图不表示视觉比对通过。旧证据必须由导出 Skill 分析 `spec.md` 后生成经过哈希和完整覆盖校验的语义分组清单，禁止按 E2E scene 猜测。
 
 ## 交付流程
 
@@ -157,6 +172,12 @@ Checker 和代码审计生成的 Markdown 使用简体中文，包括标题、
 5. Blocked 时进入人工决策；只有用户选择 `stop` 才终止。
 6. 验收通过或用户接受 waiver 后，`$code-audit` 审查代码规范和规格符合度。
 
+### 快速流程 `$delivery-loop-fast`
+
+快速流程由用户显式选择，不进行风险评分，也不会自动切换为完整流程。当前 Agent 根据 spec 实现代码、执行仓库定向检查，并使用上述交互式 Playwright 工具自测、截图和自查自纠；业务代码或测试步骤变化后开启新的完整自测 iteration。最新快速自测通过后，再由全新的独立 `$code-audit` 代理审查固定范围。审计发现阻断问题时，当前 Agent 修复后必须重新完成仓库检查、快速自测和独立审计。
+
+快速流程不生成持久化 E2E 场景、测试编写者结果或 Checker 结果。完成条件仍包括：最新交互式自测通过、每个报告功能组具备截图、独立代码审计通过，并且证据与状态一致。现有 `$delivery-loop` 的角色隔离、冻结 E2E 和可见验收流程保持不变。
+
 运行器或工具故障不消耗实现者修复回合。隔离 scene 会先继续执行其他场景，再进入 `awaiting-decision`；用户可查看可见浏览器和完整的其余场景证据后重试、确认、跳过、分类为实现/测试缺陷或停止。
 
 ## 源码开发与验证

package/plugins/autobest-delivery/mcp-server/package.json

@@ -7,7 +7,7 @@
     "node": ">=20"
   },
   "scripts": {
-    "lint": "node --check ../scripts/setup.mjs && node --check ../scripts/start-mcp.mjs && node --check ../scripts/export-delivery-report.mjs && node --check src/paths.mjs && node --check src/report.mjs && node --check src/runner.mjs && node --check src/server.mjs && node --check tests/fixture-server.mjs && node --check tests/report.test.mjs && node --check tests/runner.test.mjs && node --check tests/mcp-smoke.test.mjs && node --check tests/fixtures/basic.feature.mjs",
+    "lint": "node --check ../scripts/setup.mjs && node --check ../scripts/start-mcp.mjs && node --check ../scripts/export-delivery-report.mjs && node --check src/paths.mjs && node --check src/report.mjs && node --check src/runner.mjs && node --check src/fast-runner.mjs && node --check src/server.mjs && node --check tests/fixture-server.mjs && node --check tests/report.test.mjs && node --check tests/runner.test.mjs && node --check tests/fast-runner.test.mjs && node --check tests/mcp-smoke.test.mjs && node --check tests/fixtures/basic.feature.mjs",
     "test": "node --test --test-concurrency=1 tests/*.test.mjs",
     "verify": "npm run lint && npm test"
   },

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

@@ -0,0 +1,470 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { resolveArtifactPath, resolveWorkspaceOutputPaths } from './paths.mjs';
+
+const fastSessions = new Map();
+const requirementIdPattern = /^REQ-[A-Z][A-Z0-9]{1,15}-\d{3}$/;
+const reportGroupPattern = /^[a-z0-9][a-z0-9._-]*$/;
+const captureNamePattern = /^[a-zA-Z0-9][a-zA-Z0-9._-]*\.png$/;
+const defaultBrowserRoot = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  '..',
+  '.runtime',
+  'ms-playwright'
+);
+process.env.PLAYWRIGHT_BROWSERS_PATH =
+  process.env.AUTOBEST_DELIVERY_BROWSERS_PATH || defaultBrowserRoot;
+
+async function loadPlaywright() {
+  return import('@playwright/test');
+}
+
+function errorDetail(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function toEvidencePath(root, absolutePath) {
+  return path.relative(root, absolutePath).split(path.sep).join('/');
+}
+
+async function sha256(filePath) {
+  const content = await fs.readFile(filePath);
+  return crypto.createHash('sha256').update(content).digest('hex');
+}
+
+async function writeJson(filePath, value) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+}
+
+function requireSession(sessionId) {
+  const session = fastSessions.get(sessionId);
+  if (!session) throw new Error(`快速验收会话不存在或已结束：${sessionId}`);
+  return session;
+}
+
+function validateReportFields(input) {
+  for (const field of ['reportModule', 'reportGroup', 'reportTitle', 'reportMethod']) {
+    if (typeof input[field] !== 'string' || !input[field].trim()) {
+      throw new TypeError(`${field} 必须是非空字符串`);
+    }
+  }
+  if (!reportGroupPattern.test(input.reportGroup)) {
+    throw new TypeError('reportGroup 必须是稳定的 ASCII ID');
+  }
+  if (input.requirementId && !requirementIdPattern.test(input.requirementId)) {
+    throw new TypeError(`无效需求 ID：${input.requirementId}`);
+  }
+}
+
+function validateRequirement(session, requirementId) {
+  if (!requirementId || session.requirementIds.size === 0) return;
+  if (!session.requirementIds.has(requirementId)) {
+    throw new TypeError(`引用了未声明的需求 ID：${requirementId}`);
+  }
+}
+
+async function closeSession(session) {
+  clearTimeout(session.timeoutId);
+  await session.context?.close().catch(() => undefined);
+  await session.browser?.close().catch(() => undefined);
+}
+
+function installPageEvidence(session, page) {
+  page.on('console', message => {
+    if (message.type() === 'error') session.consoleErrors.push(message.text());
+  });
+  page.on('requestfailed', request => {
+    session.networkFailures.push({
+      url: request.url(),
+      method: request.method(),
+      errorText: request.failure()?.errorText || 'unknown'
+    });
+  });
+  page.on('response', response => {
+    const request = response.request();
+    session.apiCalls.push({
+      url: response.url(),
+      method: request.method(),
+      status: response.status()
+    });
+  });
+}
+
+export async function startFastCheck({
+  workspaceRoot,
+  baseUrl,
+  outputDir,
+  apiMode = 'none',
+  iteration = 1,
+  headed = false,
+  viewport = { width: 1400, height: 1000 },
+  requirementIds = [],
+  sessionTtlMs = 3600000
+}) {
+  if (requirementIds.some(requirementId => !requirementIdPattern.test(requirementId))) {
+    throw new TypeError('requirementIds 包含格式错误的需求 ID');
+  }
+  if (new Set(requirementIds).size !== requirementIds.length) {
+    throw new TypeError('requirementIds 不得重复');
+  }
+  const { root, output } = await resolveWorkspaceOutputPaths({ workspaceRoot, outputDir });
+  const { chromium } = await loadPlaywright();
+  const browser = await chromium.launch({ headless: !headed });
+  const context = await browser.newContext({ viewport });
+  await context.tracing.start({ screenshots: true, snapshots: true, sources: false });
+  const page = await context.newPage();
+  const sessionId = crypto.randomUUID();
+  const session = {
+    sessionId,
+    root,
+    output,
+    baseUrl,
+    apiMode,
+    iteration,
+    headed,
+    viewport,
+    browser,
+    context,
+    page,
+    requirementIds: new Set(requirementIds),
+    checks: [],
+    captures: [],
+    actions: [],
+    apiCalls: [],
+    consoleErrors: [],
+    networkFailures: [],
+    blockers: [],
+    startedAt: new Date().toISOString()
+  };
+  installPageEvidence(session, page);
+  session.timeoutId = setTimeout(async () => {
+    fastSessions.delete(sessionId);
+    await closeSession(session);
+  }, sessionTtlMs);
+  session.timeoutId.unref?.();
+  fastSessions.set(sessionId, session);
+  try {
+    await page.goto(baseUrl);
+    session.actions.push({ action: 'navigate', url: page.url(), success: true });
+  } catch (error) {
+    session.actions.push({ action: 'navigate', url: baseUrl, success: false, error: errorDetail(error) });
+  }
+  return {
+    sessionId,
+    url: page.url(),
+    title: await page.title().catch(() => ''),
+    browserMode: headed ? 'headed' : 'headless',
+    outputDir: toEvidencePath(root, output),
+    expiresInMs: sessionTtlMs
+  };
+}
+
+export async function fastBrowserSnapshot({ sessionId, timeoutMs = 10000 }) {
+  const session = requireSession(sessionId);
+  const snapshot = await session.page.locator('body').ariaSnapshot({ timeout: timeoutMs });
+  return {
+    sessionId,
+    url: session.page.url(),
+    title: await session.page.title(),
+    snapshot: snapshot.slice(0, 30000)
+  };
+}
+
+export async function fastBrowserAction({
+  sessionId,
+  action,
+  locator,
+  value,
+  url,
+  width,
+  height,
+  timeoutMs = 10000
+}) {
+  const session = requireSession(sessionId);
+  const page = session.page;
+  try {
+    if (['click', 'fill', 'select', 'press', 'wait'].includes(action) && !locator) {
+      throw new TypeError(`${action} 操作必须提供 locator`);
+    }
+    if (action === 'viewport' && (!width || !height)) {
+      throw new TypeError('viewport 操作必须提供 width 和 height');
+    }
+    if (action === 'navigate') {
+      await page.goto(new URL(url || session.baseUrl, session.baseUrl).toString(), { timeout: timeoutMs });
+    } else if (action === 'click') {
+      await page.locator(locator).click({ timeout: timeoutMs });
+    } else if (action === 'fill') {
+      await page.locator(locator).fill(value ?? '', { timeout: timeoutMs });
+    } else if (action === 'select') {
+      await page.locator(locator).selectOption(value ?? '', { timeout: timeoutMs });
+    } else if (action === 'press') {
+      await page.locator(locator).press(value ?? '', { timeout: timeoutMs });
+    } else if (action === 'wait') {
+      await page.locator(locator).waitFor({ state: 'visible', timeout: timeoutMs });
+    } else if (action === 'viewport') {
+      await page.setViewportSize({ width, height });
+      session.viewport = { width, height };
+    } else {
+      throw new TypeError(`不支持的快速浏览器操作：${action}`);
+    }
+    const result = { action, locator: locator || null, value: value ?? null, url: page.url(), success: true };
+    session.actions.push(result);
+    return { sessionId, ...result };
+  } catch (error) {
+    const result = {
+      action,
+      locator: locator || null,
+      value: value ?? null,
+      url: page.url(),
+      success: false,
+      error: errorDetail(error)
+    };
+    session.actions.push(result);
+    return { sessionId, ...result };
+  }
+}
+
+export async function mockFastCheckRoute({ sessionId, method = 'GET', pathname, status = 200, body = {} }) {
+  const session = requireSession(sessionId);
+  if (session.apiMode !== 'mock') throw new Error('只有 mock 模式可以安装请求响应');
+  await session.page.route(`**${pathname}`, async route => {
+    if (route.request().method() !== method) return route.fallback();
+    await route.fulfill({ status, contentType: 'application/json', body: JSON.stringify(body) });
+  });
+  return { sessionId, method, pathname, status, success: true };
+}
+
+async function evaluateCheck(session, input) {
+  const page = session.page;
+  const target = input.locator ? page.locator(input.locator) : null;
+  if (input.checkType !== 'url' && !target) {
+    throw new TypeError(`${input.checkType} 检查必须提供 locator`);
+  }
+  if (['text', 'value', 'url', 'attribute', 'css'].includes(input.checkType) && typeof input.expected !== 'string') {
+    throw new TypeError(`${input.checkType} 检查必须提供 expected`);
+  }
+  if (input.checkType === 'count' && !Number.isInteger(input.expectedNumber)) {
+    throw new TypeError('count 检查必须提供 expectedNumber');
+  }
+  if (['attribute', 'css'].includes(input.checkType) && !input.property) {
+    throw new TypeError(`${input.checkType} 检查必须提供 property`);
+  }
+  if (input.checkType === 'visible') return target.isVisible({ timeout: input.timeoutMs });
+  if (input.checkType === 'hidden') return !(await target.isVisible({ timeout: input.timeoutMs }));
+  if (input.checkType === 'text') {
+    const actual = (await target.textContent({ timeout: input.timeoutMs })) || '';
+    return { actual, isPass: input.exact ? actual.trim() === input.expected : actual.includes(input.expected) };
+  }
+  if (input.checkType === 'value') {
+    const actual = await target.inputValue({ timeout: input.timeoutMs });
+    return { actual, isPass: actual === input.expected };
+  }
+  if (input.checkType === 'count') {
+    const actual = await target.count();
+    return { actual, isPass: actual === input.expectedNumber };
+  }
+  if (input.checkType === 'url') {
+    const actual = page.url();
+    return { actual, isPass: input.exact ? actual === input.expected : actual.includes(input.expected) };
+  }
+  if (input.checkType === 'attribute') {
+    const actual = await target.getAttribute(input.property, { timeout: input.timeoutMs });
+    return { actual, isPass: actual === input.expected };
+  }
+  if (input.checkType === 'css') {
+    const actual = await target.evaluate((element, property) => getComputedStyle(element).getPropertyValue(property), input.property);
+    return { actual, isPass: actual.trim() === input.expected };
+  }
+  throw new TypeError(`不支持的检查类型：${input.checkType}`);
+}
+
+export async function fastBrowserCheck(input) {
+  const session = requireSession(input.sessionId);
+  validateReportFields(input);
+  validateRequirement(session, input.requirementId);
+  if (session.checks.some(check => check.id === input.id)) {
+    throw new TypeError(`检查 ID 不得重复：${input.id}`);
+  }
+  let actual;
+  let isPass;
+  try {
+    const evaluated = await evaluateCheck(session, input);
+    if (typeof evaluated === 'boolean') {
+      actual = evaluated ? '条件满足' : '条件不满足';
+      isPass = evaluated;
+    } else {
+      actual = evaluated.actual;
+      isPass = evaluated.isPass;
+    }
+  } catch (error) {
+    actual = errorDetail(error);
+    isPass = false;
+  }
+  const check = {
+    id: input.id,
+    requirementId: input.requirementId || null,
+    specSnippet: input.specSnippet,
+    reportModule: input.reportModule,
+    reportGroup: input.reportGroup,
+    reportTitle: input.reportTitle,
+    reportMethod: input.reportMethod,
+    checkType: input.checkType,
+    locator: input.locator || null,
+    expect: input.expect,
+    actual: actual === null || actual === undefined ? '' : String(actual),
+    isPass
+  };
+  session.checks.push(check);
+  return { sessionId: input.sessionId, check };
+}
+
+export async function captureFastCheck(input) {
+  const session = requireSession(input.sessionId);
+  validateReportFields(input);
+  validateRequirement(session, input.requirementId);
+  if (!captureNamePattern.test(input.capture)) {
+    throw new TypeError('capture 必须是简单的 PNG 文件名');
+  }
+  if (!['desktop', 'mobile'].includes(input.reportDevice)) {
+    throw new TypeError('reportDevice 必须是 desktop 或 mobile');
+  }
+  if (session.captures.some(capture => capture.capture === input.capture)) {
+    throw new TypeError(`截图文件名不得重复：${input.capture}`);
+  }
+  const capturePath = resolveArtifactPath(session.output, path.join('captures', input.capture));
+  await fs.mkdir(path.dirname(capturePath), { recursive: true });
+  if (input.locator) {
+    await session.page.locator(input.locator).screenshot({ path: capturePath });
+  } else {
+    await session.page.screenshot({ path: capturePath, fullPage: input.fullPage !== false });
+  }
+  const evidencePath = toEvidencePath(session.root, capturePath);
+  const capture = {
+    requirementId: input.requirementId || null,
+    capture: input.capture,
+    locator: input.locator || 'page',
+    reportModule: input.reportModule,
+    reportGroup: input.reportGroup,
+    reportTitle: input.reportTitle,
+    reportMethod: input.reportMethod,
+    reportDevice: input.reportDevice,
+    path: evidencePath,
+    sha256: await sha256(capturePath)
+  };
+  session.captures.push(capture);
+  return { sessionId: input.sessionId, capture };
+}
+
+function fastResultMarkdown(result) {
+  const lines = [
+    '# 快速 Playwright 自测结果',
+    '',
+    `- 状态：${result.status}`,
+    `- 证据来源：交互式 Playwright 自测`,
+    `- 迭代：${result.iteration}`,
+    `- API 模式：${result.apiMode}`,
+    '',
+    '## 检查结果',
+    '',
+    '| 检查 | 预期 | 实际 | 状态 |',
+    '| --- | --- | --- | --- |',
+    ...result.checks.map(check =>
+      `| ${check.reportTitle} | ${check.expect} | ${String(check.actual).replaceAll('|', '\\|')} | ${check.isPass ? '通过' : '不通过'} |`
+    ),
+    '',
+    '## 截图',
+    '',
+    ...result.captureRecords.map(capture => `- ${capture.reportTitle}（${capture.reportDevice}）：${capture.path}`),
+    ''
+  ];
+  return lines.join('\n');
+}
+
+export async function finishFastCheck({ sessionId }) {
+  const session = requireSession(sessionId);
+  fastSessions.delete(sessionId);
+  const tracePath = resolveArtifactPath(session.output, 'trace.zip');
+  try {
+    await session.context.tracing.stop({ path: tracePath });
+  } catch (error) {
+    session.blockers.push({ kind: 'trace', detail: errorDetail(error) });
+  }
+  if (session.checks.length === 0) session.blockers.push({ kind: 'evidence', detail: '没有记录检查项' });
+  if (session.captures.length === 0) session.blockers.push({ kind: 'evidence', detail: '没有记录报告截图' });
+  const coveredRequirementIds = new Set(
+    session.checks.map(check => check.requirementId).filter(Boolean)
+  );
+  for (const requirementId of session.requirementIds) {
+    if (!coveredRequirementIds.has(requirementId)) {
+      session.blockers.push({ kind: 'traceability', detail: `需求 ${requirementId} 没有检查证据` });
+    }
+  }
+  const capturedGroups = new Set(session.captures.map(capture => capture.reportGroup));
+  for (const reportGroup of new Set(session.checks.map(check => check.reportGroup))) {
+    if (!capturedGroups.has(reportGroup)) {
+      session.blockers.push({ kind: 'report-capture', detail: `报告功能组 ${reportGroup} 没有截图` });
+    }
+  }
+  const status = session.blockers.length > 0
+    ? 'blocked'
+    : session.checks.some(check => !check.isPass) ? 'failed' : 'passed';
+  const resultPath = resolveArtifactPath(session.output, 'fast-check-result.json');
+  const markdownPath = resolveArtifactPath(session.output, 'fast-check-result.md');
+  const result = {
+    evidenceSchemaVersion: 1,
+    evidenceSource: 'interactive-playwright',
+    status,
+    iteration: session.iteration,
+    scenarioPath: null,
+    scenarioSha256: null,
+    metadata: {
+      apiMode: session.apiMode,
+      requirementIds: [...session.requirementIds],
+      reportCaptures: session.captures.map(({ path: _path, sha256: _sha256, ...capture }) => capture),
+      visualMappings: []
+    },
+    apiMode: session.apiMode,
+    apiCalls: session.apiCalls,
+    checks: session.checks,
+    captures: session.captures.map(capture => capture.path),
+    captureRecords: session.captures,
+    actions: session.actions,
+    tracePath: session.blockers.some(blocker => blocker.kind === 'trace') ? null : toEvidencePath(session.root, tracePath),
+    consoleErrors: session.consoleErrors,
+    networkFailures: session.networkFailures,
+    blockers: session.blockers,
+    browserMode: session.headed ? 'headed' : 'headless',
+    startedAt: session.startedAt,
+    finishedAt: new Date().toISOString(),
+    resultPath: toEvidencePath(session.root, resultPath)
+  };
+  try {
+    await writeJson(resultPath, result);
+    await fs.writeFile(markdownPath, fastResultMarkdown(result), 'utf8');
+    return { ...result, markdownPath: toEvidencePath(session.root, markdownPath) };
+  } finally {
+    await closeSession(session);
+  }
+}
+
+export async function abortFastCheck({ sessionId }) {
+  const session = fastSessions.get(sessionId);
+  if (!session) return { status: 'not-found', sessionId };
+  fastSessions.delete(sessionId);
+  await closeSession(session);
+  return { status: 'aborted', sessionId };
+}
+
+export async function closeAllFastChecks() {
+  const sessions = [...fastSessions.values()];
+  fastSessions.clear();
+  await Promise.all(sessions.map(closeSession));
+}
+
+export function activeFastCheckCount() {
+  return fastSessions.size;
+}

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

@@ -13,14 +13,9 @@ function isInside(root, target) {
   return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
 }
 
-export async function resolveWorkspacePaths({ workspaceRoot, scenarioPath, outputDir }) {
+export async function resolveWorkspaceOutputPaths({ workspaceRoot, outputDir }) {
   const root = await fs.realpath(path.resolve(workspaceRoot));
-  const scenario = await fs.realpath(path.resolve(root, scenarioPath));
   const output = path.resolve(root, outputDir);
-
-  if (!isInside(root, scenario)) {
-    throw new PathPolicyError('scenarioPath 必须位于 workspaceRoot 内');
-  }
   if (!isInside(root, output)) {
     throw new PathPolicyError('outputDir 必须位于 workspaceRoot 内');
   }
@@ -30,8 +25,18 @@ export async function resolveWorkspacePaths({ workspaceRoot, scenarioPath, outpu
   if (!isInside(root, realOutput)) {
     throw new PathPolicyError('outputDir 解析后的路径位于 workspaceRoot 外');
   }
+  return { root, output: realOutput };
+}
 
-  return { root, scenario, output: realOutput };
+export async function resolveWorkspacePaths({ workspaceRoot, scenarioPath, outputDir }) {
+  const root = await fs.realpath(path.resolve(workspaceRoot));
+  const scenario = await fs.realpath(path.resolve(root, scenarioPath));
+
+  if (!isInside(root, scenario)) {
+    throw new PathPolicyError('scenarioPath 必须位于 workspaceRoot 内');
+  }
+  const resolved = await resolveWorkspaceOutputPaths({ workspaceRoot: root, outputDir });
+  return { root, scenario, output: resolved.output };
 }
 
 export function resolveArtifactPath(outputDir, relativePath) {