@autobest-ui/agent 1.0.10 → 1.0.11

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',
   {
@@ -198,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')
+  ));
+});

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

@@ -35,6 +35,21 @@ test('stdio MCP 能暴露环境信息并执行功能场景', async t => {
   await client.connect(transport);
   t.after(() => client.close());
 
+  const { tools } = await client.listTools();
+  const toolNames = tools.map(tool => tool.name);
+  for (const toolName of [
+    'start_fast_check',
+    'fast_browser_snapshot',
+    'fast_browser_action',
+    'mock_fast_check_route',
+    'fast_browser_check',
+    'capture_fast_check',
+    'finish_fast_check',
+    'abort_fast_check'
+  ]) {
+    assert.ok(toolNames.includes(toolName), `缺少 MCP 工具 ${toolName}`);
+  }
+
   const environment = await client.callTool({
     name: 'check_environment',
     arguments: {}
@@ -57,6 +72,62 @@ test('stdio MCP 能暴露环境信息并执行功能场景', async t => {
   assert.equal(execution.structuredContent.status, 'passed');
   assert.equal(execution.structuredContent.checks.length, 2);
 
+  const fastStarted = await client.callTool({
+    name: 'start_fast_check',
+    arguments: {
+      workspaceRoot,
+      baseUrl: fixture.baseUrl,
+      outputDir: 'feature/fast-check/runs/iteration-01'
+    }
+  });
+  const fastSessionId = fastStarted.structuredContent.sessionId;
+  const fastSnapshot = await client.callTool({
+    name: 'fast_browser_snapshot',
+    arguments: { sessionId: fastSessionId }
+  });
+  assert.match(fastSnapshot.structuredContent.snapshot, /显示结果/);
+
+  await client.callTool({
+    name: 'fast_browser_action',
+    arguments: { sessionId: fastSessionId, action: 'click', locator: '#reveal' }
+  });
+  const fastCheck = await client.callTool({
+    name: 'fast_browser_check',
+    arguments: {
+      sessionId: fastSessionId,
+      id: 'story-01',
+      reportModule: '交付测试页',
+      reportGroup: 'reveal-result',
+      reportTitle: '结果展示',
+      reportMethod: '通过交互式 Playwright 点击按钮并检查结果文案。',
+      specSnippet: '点击按钮后显示结果。',
+      expect: '结果文案可见',
+      checkType: 'text',
+      locator: '#result',
+      expected: '运行器运行正常'
+    }
+  });
+  assert.equal(fastCheck.structuredContent.check.isPass, true);
+  await client.callTool({
+    name: 'capture_fast_check',
+    arguments: {
+      sessionId: fastSessionId,
+      reportModule: '交付测试页',
+      reportGroup: 'reveal-result',
+      reportTitle: '结果展示',
+      reportMethod: '通过交互式 Playwright 点击按钮并检查结果文案。',
+      capture: 'result-desktop.png',
+      locator: 'main',
+      reportDevice: 'desktop'
+    }
+  });
+  const fastFinished = await client.callTool({
+    name: 'finish_fast_check',
+    arguments: { sessionId: fastSessionId }
+  });
+  assert.equal(fastFinished.structuredContent.status, 'passed');
+  assert.equal(fastFinished.structuredContent.scenarioPath, null);
+
   const rejectedPath = await client.callTool({
     name: 'run_feature_e2e',
     arguments: {

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

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict';
 import { createHash } from 'node:crypto';
-import { mkdtemp, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import test from 'node:test';
@@ -202,6 +202,74 @@ test('REQ 分节规格可从检查映射导出并嵌入报告截图', async () =
   assert.match(workbook.getWorksheet('自测报告').getCell('C2').value, /^API 数据：模拟 API。/);
 });
 
+test('交互式快速自测结果无需 E2E 场景和 Checker 即可导出报告', async t => {
+  const workspaceRoot = await mkdtemp(path.join(os.tmpdir(), 'autobest-fast-report-'));
+  t.after(() => rm(workspaceRoot, { recursive: true, force: true }));
+  await mkdir(path.join(workspaceRoot, '.git'));
+  const featureDir = path.join(workspaceRoot, '.scratch', 'fast-feature');
+  const runDir = path.join(featureDir, 'fast-check', 'runs', 'iteration-01');
+  const capturePath = path.join(runDir, 'captures', 'heading-desktop.png');
+  await mkdir(path.dirname(capturePath), { recursive: true });
+  await writeFile(capturePath, png);
+  await writeFile(
+    path.join(featureDir, 'spec.md'),
+    '# 页面规格\n\n## 用户故事\n\n1. 页面显示标题。\n'
+  );
+  const relativeCapture = path.relative(workspaceRoot, capturePath).split(path.sep).join('/');
+  await writeFile(
+    path.join(runDir, 'fast-check-result.json'),
+    JSON.stringify({
+      evidenceSchemaVersion: 1,
+      evidenceSource: 'interactive-playwright',
+      status: 'passed',
+      iteration: 1,
+      scenarioPath: null,
+      scenarioSha256: null,
+      apiMode: 'none',
+      metadata: {
+        apiMode: 'none',
+        reportCaptures: [{
+          capture: 'heading-desktop.png',
+          locator: 'h1',
+          reportModule: '示例页面',
+          reportGroup: 'page-heading',
+          reportTitle: '页面标题',
+          reportMethod: '通过交互式 Playwright 检查标题并截图。',
+          reportDevice: 'desktop'
+        }],
+        visualMappings: []
+      },
+      checks: [{
+        id: 'story-01',
+        specSnippet: '页面显示标题。',
+        reportModule: '示例页面',
+        reportGroup: 'page-heading',
+        reportTitle: '页面标题',
+        reportMethod: '通过交互式 Playwright 检查标题并截图。',
+        expect: '标题可见',
+        actual: '标题可见',
+        isPass: true
+      }],
+      captures: [relativeCapture]
+    })
+  );
+
+  const result = await exportDeliveryReport({ featureDir, workspaceRoot, templatePath });
+  assert.equal(result.evidenceSource, 'interactive-playwright');
+  assert.equal(result.checkerStatus, null);
+  assert.equal(result.runnerStatus, null);
+  assert.equal(result.fastCheckStatus, 'passed');
+  assert.equal(result.apiMode, 'none');
+  assert.equal(result.rows, 1);
+  assert.equal(result.embeddedScreenshots, 1);
+
+  const workbook = new ExcelJS.Workbook();
+  await workbook.xlsx.readFile(result.outputPath);
+  const worksheet = workbook.getWorksheet('自测报告');
+  assert.equal(worksheet.getCell('B2').value, '页面标题');
+  assert.match(worksheet.getCell('C2').value, /^API 数据：本次未指定业务 API。/);
+});
+
 test('旧证据必须提供完整语义分组清单，不能按 scene 猜测功能', async () => {
   const { workspaceRoot, featureDir, runDir, desktop, mobile } = await createFixture();
   const runnerPath = path.join(runDir, 'runner-result.json');

package/plugins/autobest-delivery/skills/code-audit/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: code-audit
-description: 在独立验收者通过后，从固定审查点检查交付改动是否符合仓库规范和功能规格。
+description: 在标准独立验收或快速交互式自测通过后，从固定审查点检查交付改动是否符合仓库规范和功能规格。
 ---
 
 # 代码审计
@@ -11,12 +11,12 @@ description: 在独立验收者通过后，从固定审查点检查交付改动
 
 - 可解析的固定审查点。
 - 功能规格及同目录的 scope。
-- 同目录存在时的 `spec-traceability.json`，以及 Maker、Checker 的逐项需求结果。
+- 同目录存在时的 `spec-traceability.json`。标准模式读取 Maker、Checker 的逐项需求结果；快速模式读取 `delivery-state.json` 和最新 `fast-check-result.json`。
 - 默认审查 `worktree`，也可审查用户明确指定的 `committed` 改动。
 
 ## 流程
 
-追踪模式下，Spec 审查轴必须逐个核对 active REQ ID 是否同时出现在 spec、Maker 结论、相关代码和 Checker 证据中；不得用整体通过代替单项覆盖，也不得接受未知或重编号的需求。
+追踪模式下，Spec 审查轴必须逐个核对 active REQ ID 是否同时出现在 spec、实现结论、相关代码和 Checker 或快速自测证据中；不得用整体通过代替单项覆盖，也不得接受未知或重编号的需求。快速模式证据只能称为实现者交互式自测，不能表述成独立 Checker 验收。
 
 1. 只冻结一次审查范围。审查工作树时纳入与任务相关的暂存、未暂存及新增文件，保留并排除无关的既有改动。
 2. 阅读适用的仓库规则、spec、scope、提交列表、改动文件和完整 diff。

package/plugins/autobest-delivery/skills/delivery-loop/references/delivery-contract.md

@@ -19,9 +19,20 @@
 | `review/code-audit-result.json` 和 `.md` | 代码审计者 | 只读 |
 | `delivery/delivery-state.json` | 编排者 | 只读 |
 | `delivery/code-craft-result.json` | 实现者 | 只读 |
+| `fast-check/runs/iteration-NN/fast-check-result.json`、`.md`、Trace 和截图 | 快速模式 MCP | 只读 |
 
 旧 `e2e.feature.spec.ts` 文件不是本契约的可执行输入。保持这些文件不变；缺少标准 `.mjs` 场景时生成新场景。
 
+## 快速交付证据
+
+`delivery-loop-fast` 是用户显式选择的快速模式。当前 Agent 同时实现业务代码并使用 MCP 交互式 Playwright 工具自测，不启动独立测试编写者或 UI Checker，不生成 `e2e/e2e.feature.mjs`、`e2e/author-result.json` 和 `checker/checker-result.*`。这条路径不进行风险分类，也不因改动类型自动切换到完整流程。
+
+每轮快速自测写入 `fast-check/runs/iteration-NN/fast-check-result.json` 和 `.md`、`trace.zip` 及 `captures/`。结果必须使用 `evidenceSchemaVersion: 1`、`evidenceSource: interactive-playwright`，包含实际检查、报告分组、截图映射、API 模式、控制台错误和网络失败。`real` 表示真实 API，`mock` 表示受控响应，`none` 表示本次没有指定需要证明的业务 API；只有 mock 模式能安装请求响应。
+
+每项检查使用稳定 ID，并包含 `specSnippet`、`expect`、`actual`、`isPass`、`reportModule`、`reportGroup`、`reportTitle` 和 `reportMethod`；追踪模式同时包含 manifest 中的 `requirementId`。每个报告功能组至少有一个 `captureRecords` 条目，包含相同的报告字段、`reportDevice`、工作区相对路径和 SHA-256。截图是运行时状态证据，不是独立验收或 Figma 一致性结论。
+
+业务代码或交互步骤修复后必须开始新的 iteration；旧结果保留但失效。最终 `passed` 需要最新快速自测通过和全新独立 `$code-audit` 通过。代码审计读取快速证据，但不能把它升级描述为独立 Checker 证据。`export-report` 可以直接读取最新快速结果，并在摘要中标记 `evidenceSource: interactive-playwright`。
+
 ## 需求追踪
 
 当功能目录包含 `spec-traceability.json` 时，交付必须按其中的 active REQ ID 运行，编号格式为 `REQ-<页面或Scope简称>-<三位序号>`。编号由上游 `ui-prd-scope` 所有；本插件的编排者、Maker、测试编写者、Checker 和 Audit 只能引用，不能创建、修改或重排。开始 Maker 前必须确认 scope、review、spec 及其 SHA-256 一致。