@kkeve/suite 0.0.15 → 0.0.18

package/dist/core/decorator/keve-decorators.js

@@ -0,0 +1,254 @@
+"use strict";
+/**
+ * keve-decorators — @keveModel + @keveScene 装饰器
+ *
+ * 使用 TC39 Stage 3 装饰器 API (Playwright 1.58+ 默认支持)
+ *
+ * 执行顺序（TC39 Stage 3 规范）：
+ * 1. Method decorator 函数调用 → 注册 addInitializer
+ * 2. Class decorator 函数调用 → 注册 addInitializer
+ * 3. Method addInitializers 执行 → @keveScene 注册场景到 WeakMap
+ * 4. Class addInitializer 执行 → @keveModel 读取 WeakMap 并调用 test.describe
+ *
+ * 两层装饰器 + 函数调用：
+ *   Model (模块) → test.describe → @keveModel(id, desc, { setup, teardown, precondition?, before? })
+ *   Scene (场景) → test → @keveScene(id, desc, { tag?, precondition?, before?, afterHook? })
+ *   Goal  (步骤) → 步骤元数据 → keveGoal() 函数调用（在方法体内，支持 precondition）
+ *
+ * @keveGroup 已消除：
+ *   - setup → @keveModel setup 选项（独立 Page，所有 Scene 前执行）
+ *   - teardown → @keveModel teardown 选项（所有 Scene 后执行，扫描 E2E_ 前缀）
+ *   - identity → Scene 内 keveGoal(fn) 中调用 globalThis.switchIdentity
+ *   - afterHook → @keveScene afterHook 选项（Scene 后保证执行）
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setKeveTestHost = setKeveTestHost;
+exports.setKeveTest = setKeveTest;
+exports.getKeveTest = getKeveTest;
+exports.hasKeveTest = hasKeveTest;
+exports.keveModel = keveModel;
+exports.keveScene = keveScene;
+exports.getModelScenes = getModelScenes;
+const keve_registry_js_1 = require("./keve-registry.js");
+const keve_host_js_1 = require("./keve-host.js");
+// ─── Configurable test reference ────────────────────────────────────
+// keveModel needs to call test.describe / test — but it must use the EXTENDED test
+// (with keveGoal/keveAssert fixtures), not the base @playwright/test.
+// 引擎入口在创建好扩展 test 后调用 setKeveTest()/setKeveHost() 完成注册：
+//   - Playwright: keve-test.ts → setKeveTest(test)
+//   - Cypress:    engine-cypress → setKeveHost(cypressHost)
+//
+// 装饰器自身不依赖任何测试框架，只面向 KeveHost 接口。
+/**
+ * 注册宿主（推荐入口，引擎无关）。
+ */
+function setKeveTestHost(host) { (0, keve_host_js_1.setKeveHost)(host); }
+/**
+ * Playwright 兼容适配：把 @playwright/test 的 test 对象包成 KeveHost。
+ * 保留该名称是为了不破坏既有调用（keve-test.ts / 外部脚本）。
+ */
+function setKeveTest(t) {
+    (0, keve_host_js_1.setKeveHost)(adaptPlaywrightTest(t));
+}
+/** 把 Playwright 的 test 对象适配成引擎无关宿主 */
+function adaptPlaywrightTest(t) {
+    const normalizeTitle = (testInfo) => String(testInfo?.title ?? '');
+    return {
+        describe: (title, fn) => t.describe(title, fn),
+        describeSerial: (title, fn) => (t.describe.serial || t.describe)(title, fn),
+        beforeAll: (fn) => t.beforeAll(fn),
+        beforeEach: (fn) => t.beforeEach(async ({}, testInfo) => {
+            const info = {
+                title: normalizeTitle(testInfo),
+                skip: (reason) => testInfo.skip(true, reason),
+            };
+            await fn(info);
+        }),
+        afterEach: (fn) => t.afterEach(async ({}, testInfo) => {
+            const info = {
+                title: normalizeTitle(testInfo),
+                skip: (reason) => testInfo.skip(true, reason),
+            };
+            await fn(info);
+        }),
+        afterAll: (fn) => t.afterAll(fn),
+        test: (title, fn) => t(title, fn),
+    };
+}
+/** Get the current keve test instance (Playwright 兼容查询；Cypress 下返回宿主) */
+function getKeveTest() { return (0, keve_host_js_1.getKeveHost)(); }
+/** 是否已注册宿主 */
+function hasKeveTest() { return (0, keve_host_js_1.hasKeveHost)(); }
+// ─── Internal Registry (WeakMap per Model constructor) ─────────────
+/** Model → Scene 列表：每个 @keveModel 类下注册的 @keveScene 列表 */
+const modelScenesMap = new WeakMap();
+/** Scene title → afterHook：@keveScene 注册的 afterHook 回调 */
+const sceneAfterHooks = new Map();
+// ─── Error Classification ──────────────────────────────────────────
+// Error classification moved to keve-report.ts onTestEnd —
+// onTestEnd has access to result.error and result.status, which is more reliable
+// than try-catch in the decorator (async rejections, test-level timeouts can bypass decorator catch).
+// ─── TC39 Stage 3 Decorators ──────────────────────────────────────
+/**
+ * @keveModel(id, description, options?) — Class decorator (模块层)
+ * Uses context.addInitializer to defer test.describe() registration
+ * until AFTER all @keveScene addInitializers have run.
+ *
+ * options.setup: 第一个 test() 调用，拥有独立 Page + keveGoal
+ * options.teardown: test.afterAll 回调，保证执行
+ */
+function keveModel(id, description, options) {
+    return (ctor, context) => {
+        context.addInitializer(function () {
+            const ctor = this;
+            const scenes = modelScenesMap.get(ctor) || [];
+            // Merge module-level precondition into each Scene's static meta
+            // (scene addInitializers have all run by now — TC39 Stage 3 ordering)
+            if (options?.precondition?.length) {
+                for (const scene of scenes) {
+                    const meta = keve_registry_js_1.sceneMetaMap.get(scene.title) || {};
+                    keve_registry_js_1.sceneMetaMap.set(scene.title, { ...meta, modelPrecondition: options.precondition });
+                }
+            }
+            // 有 setup 时使用 serial：确保 setup 先执行，setup 失败则 Scene 跳过
+            // 无 setup 时使用普通 describe：Scene 可并行（实际 CDP 模式下仍串行）
+            const host = (0, keve_host_js_1.getKeveHost)();
+            const describeFn = options?.setup
+                ? host.describeSerial
+                : host.describe;
+            describeFn(`${id}: ${description}`, () => {
+                // ── Module-level before: executable precondition check ──
+                // Runs once before all Scenes (beforeAll). Returns false or throws
+                // → beforeAll fails → Playwright skips every Scene in this Model.
+                // Semantics: precondition unmet = skipped (blocked), NOT failed.
+                if (options?.before) {
+                    host.beforeAll(async () => {
+                        let ok = false;
+                        let beforeError;
+                        try {
+                            ok = await options.before();
+                        }
+                        catch (err) {
+                            beforeError = err;
+                        }
+                        if (!ok) {
+                            const reason = beforeError
+                                ? `Module precondition check errored: ${beforeError?.message || beforeError}`
+                                : `Module precondition not met (before returned false)`;
+                            console.log(`[keveModel] ⏭️ "${id}" SKIPPED — ${reason}`);
+                            throw new Error(reason);
+                        }
+                        console.log(`[keveModel] ✅ "${id}" module precondition check passed`);
+                    });
+                }
+                // ── Setup test (if provided) ──
+                // 独立 Page，完成后 Playwright 自动回收；keveGoal fixture 可用
+                if (options?.setup) {
+                    host.test(`${id}: ⚙ Module Setup`, options.setup);
+                }
+                // ── Scene tests ──
+                for (const scene of scenes) {
+                    host.test(scene.title, scene.fn);
+                    // ── Scene-level before: executable precondition check ──
+                    // Scoped to this Scene by title match. Returns false or throws
+                    // → skip this Scene only (precondition unmet = blocked, NOT fail).
+                    if (scene.before) {
+                        const sceneBefore = scene.before;
+                        host.beforeEach(async (testInfo) => {
+                            if (testInfo.title !== scene.title)
+                                return;
+                            let ok = false;
+                            let beforeError;
+                            try {
+                                ok = await sceneBefore();
+                            }
+                            catch (err) {
+                                beforeError = err;
+                            }
+                            if (!ok) {
+                                const reason = beforeError
+                                    ? `Scene precondition check errored: ${beforeError?.message || beforeError}`
+                                    : `Scene precondition not met (before returned false)`;
+                                console.log(`[keveScene] ⏭️ "${scene.title}" SKIPPED — ${reason}`);
+                                testInfo.skip(reason);
+                            }
+                        });
+                    }
+                }
+                // ── afterEach: run scene afterHooks ──
+                // 检查当前 test title 是否注册了 afterHook，有则调用
+                // afterHook 无测试框架 fixture —— 纯异步函数
+                host.afterEach(async (testInfo) => {
+                    const afterHook = sceneAfterHooks.get(testInfo.title);
+                    if (afterHook) {
+                        try {
+                            await afterHook();
+                        }
+                        catch (err) {
+                            console.error(`[keveScene] afterHook error for "${testInfo.title}": ${err?.message || err}`);
+                        }
+                    }
+                });
+                // ── afterAll: run module teardown ──
+                // 保证执行，即使有 Scene 失败/超时
+                if (options?.teardown) {
+                    host.afterAll(async () => {
+                        try {
+                            await options.teardown();
+                        }
+                        catch (err) {
+                            console.error(`[keveModel] teardown error for "${id}": ${err?.message || err}`);
+                        }
+                    });
+                }
+            });
+        });
+        return ctor;
+    };
+}
+/**
+ * @keveScene(id, description, options?) — Method decorator (场景层, static methods only)
+ * Captures fn.toString() as the complete scene script.
+ * Registers scene metadata to both WeakMap and global Map.
+ * If options.afterHook is provided, registers it in sceneAfterHooks Map
+ * for afterEach consumption.
+ *
+ * Returns the original function unchanged — Playwright resolves fixture dependencies
+ * by parsing fn.toString() / AST. Wrapping would break this resolution.
+ */
+function keveScene(id, description, options) {
+    // fn 用 any：装饰器原样返回方法本体，类型需与方法签名（fixtures 参数）兼容，Function 会触发 TS1270
+    return (fn, context) => {
+        const code = fn.toString(); // Capture original code BEFORE any wrapping
+        const title = `${id}: ${description}`;
+        context.addInitializer(function () {
+            const ctor = this;
+            if (!modelScenesMap.has(ctor))
+                modelScenesMap.set(ctor, []);
+            const scene = {
+                id, description, title, code, goals: [], fn,
+                precondition: options?.precondition,
+                before: options?.before,
+                afterHook: options?.afterHook,
+            };
+            modelScenesMap.get(ctor).push(scene);
+            // Register to global maps for Reporter access
+            keve_registry_js_1.sceneCodeMap.set(title, code); // Stores ORIGINAL code, not wrapped
+            // Register scene implementation for engine.callScene composition
+            keve_registry_js_1.sceneImplMap.set(id, fn);
+            // Register scene-level static meta (model-level precondition merged
+            // later in keveModel's addInitializer, which runs after all scenes registered)
+            keve_registry_js_1.sceneMetaMap.set(title, { precondition: options?.precondition });
+            // Register afterHook for afterEach consumption
+            if (options?.afterHook) {
+                sceneAfterHooks.set(title, options.afterHook);
+            }
+        });
+        return fn; // Return original function unchanged — preserves fixture parameter signature
+    };
+}
+// ─── Utility ───────────────────────────────────────────────────────
+/** 获取 Model 下注册的所有 Scene */
+function getModelScenes(ctor) {
+    return modelScenesMap.get(ctor) || null;
+}

package/dist/core/decorator/keve-host.d.ts

@@ -0,0 +1,40 @@
+/**
+ * keve-host — 装饰器宿主抽象
+ *
+ * @keveModel / @keveScene 只依赖本接口，不直接依赖任何测试框架：
+ *   - Playwright: keve-test.ts 把扩展后的 test 适配成 KeveHost
+ *   - Cypress:    engine-cypress/host.ts 把 cy / describe / it 适配成 KeveHost
+ *
+ * 这样同一份装饰器脚本可同时跑在两个引擎下，且注册进 keve-registry 的
+ * 场景元数据完全一致 —— 这是两端报告能够对齐的根本原因。
+ *
+ * 本模块必须保持零依赖（浏览器安全），Cypress spec 会直接打包它。
+ */
+/** 用例信息：装饰器在 beforeEach / afterEach 中需要的子集 */
+export interface KeveTestInfo {
+    /** 用例完整标题（`${id}: ${description}`），用于与 scene.title 匹配 */
+    title: string;
+    /** 标记跳过。前置条件不满足 → blocked（跳过），不是 fail */
+    skip(reason?: string): void;
+}
+/**
+ * 测试框架宿主能力：恰好是 @keveModel/@keveScene 需要的全部注册原语。
+ * 刻意保持最小 —— 任何新增能力都必须同时能被 Playwright 与 Cypress 表达。
+ */
+export interface KeveHost {
+    /** 注册一个 describe 分组 */
+    describe(title: string, fn: () => void): void;
+    /** 注册串行 describe：Model 带 setup 时使用，保证 setup 先于各 Scene 执行 */
+    describeSerial(title: string, fn: () => void): void;
+    beforeAll(fn: () => Promise<void> | void): void;
+    beforeEach(fn: (testInfo: KeveTestInfo) => Promise<void> | void): void;
+    afterEach(fn: (testInfo: KeveTestInfo) => Promise<void> | void): void;
+    afterAll(fn: () => Promise<void> | void): void;
+    /** 注册一个 Scene 用例 */
+    test(title: string, fn: Function): void;
+}
+/** 由引擎入口调用（keve-test.ts / engine-cypress）。后注册者生效。 */
+export declare function setKeveHost(host: KeveHost): void;
+/** 获取当前宿主；未注册时抛出可诊断的错误（而非 undefined 崩溃） */
+export declare function getKeveHost(): KeveHost;
+export declare function hasKeveHost(): boolean;

package/dist/core/decorator/keve-host.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * keve-host — 装饰器宿主抽象
+ *
+ * @keveModel / @keveScene 只依赖本接口，不直接依赖任何测试框架：
+ *   - Playwright: keve-test.ts 把扩展后的 test 适配成 KeveHost
+ *   - Cypress:    engine-cypress/host.ts 把 cy / describe / it 适配成 KeveHost
+ *
+ * 这样同一份装饰器脚本可同时跑在两个引擎下，且注册进 keve-registry 的
+ * 场景元数据完全一致 —— 这是两端报告能够对齐的根本原因。
+ *
+ * 本模块必须保持零依赖（浏览器安全），Cypress spec 会直接打包它。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setKeveHost = setKeveHost;
+exports.getKeveHost = getKeveHost;
+exports.hasKeveHost = hasKeveHost;
+let _host = null;
+/** 由引擎入口调用（keve-test.ts / engine-cypress）。后注册者生效。 */
+function setKeveHost(host) {
+    _host = host;
+}
+/** 获取当前宿主；未注册时抛出可诊断的错误（而非 undefined 崩溃） */
+function getKeveHost() {
+    if (!_host) {
+        throw new Error('[keve] 测试宿主未注册：请先 import 引擎入口'
+            + '（@kkeve/suite/keve-test 或 @kkeve/suite/engine-cypress）再做场景注册');
+    }
+    return _host;
+}
+function hasKeveHost() {
+    return _host !== null;
+}

package/dist/core/{keve-registry.d.ts → decorator/keve-registry.d.ts}

@@ -36,3 +36,22 @@ export declare const sceneGoalsMap: Map<string, KeveGoalMeta[]>;
  * @keveScene 装饰器在执行后写入分类结果，Reporter 在 onTestEnd 中读取
  */
 export declare const sceneEvalMetaMap: Map<string, KeveEvalMeta>;
+/** 场景静态元数据（编译期已知，不依赖执行） */
+export interface KeveSceneStaticMeta {
+    /** 用例级前置条件描述列表（声明式，来自 @keveScene options） */
+    precondition?: string[];
+    /** 所属 Model 的模块级前置条件描述列表 */
+    modelPrecondition?: string[];
+}
+/**
+ * 场景静态元数据映射: scene title → KeveSceneStaticMeta
+ * @keveScene 装饰器在注册期写入，Reporter/平台解析侧读取
+ * （Reporter 无需等待场景执行即可拿到前置条件，用于报告展示与 blocked 归因）
+ */
+export declare const sceneMetaMap: Map<string, KeveSceneStaticMeta>;
+/**
+ * 场景实现映射: scene id（如 'S4'）→ 场景静态方法本体
+ * @keveScene 装饰器在注册期写入；engine.callScene(id, keveGoal) 运行时查找调用，
+ * 实现「用例组合用例」而无需 spec 文件互相 import（避免重复注册测试）
+ */
+export declare const sceneImplMap: Map<string, Function>;

package/dist/core/{keve-registry.js → decorator/keve-registry.js}

@@ -7,7 +7,7 @@
  * can import it without pulling Playwright into the report build.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sceneEvalMetaMap = exports.sceneGoalsMap = exports.sceneCodeMap = void 0;
+exports.sceneImplMap = exports.sceneMetaMap = exports.sceneEvalMetaMap = exports.sceneGoalsMap = exports.sceneCodeMap = void 0;
 // ─── Global Registry ──────────────────────────────────────────────
 /**
  * 场景代码映射: scene title → scene code (fn.toString())
@@ -23,3 +23,15 @@ exports.sceneGoalsMap = new Map();
  * @keveScene 装饰器在执行后写入分类结果，Reporter 在 onTestEnd 中读取
  */
 exports.sceneEvalMetaMap = new Map();
+/**
+ * 场景静态元数据映射: scene title → KeveSceneStaticMeta
+ * @keveScene 装饰器在注册期写入，Reporter/平台解析侧读取
+ * （Reporter 无需等待场景执行即可拿到前置条件，用于报告展示与 blocked 归因）
+ */
+exports.sceneMetaMap = new Map();
+/**
+ * 场景实现映射: scene id（如 'S4'）→ 场景静态方法本体
+ * @keveScene 装饰器在注册期写入；engine.callScene(id, keveGoal) 运行时查找调用，
+ * 实现「用例组合用例」而无需 spec 文件互相 import（避免重复注册测试）
+ */
+exports.sceneImplMap = new Map();

package/dist/core/generateReport/report.d.ts

@@ -4,7 +4,7 @@
  * 只生成 report-data.json — 前端 Vue 报告页面消费的唯一数据源。
  * 废弃的产物：execution-summary.json、summary-report.html（数据均已在 report-data.json 中）
  */
-import { type ReportDataOptions } from './reportData';
+import { type ReportDataOptions } from './reportData.js';
 export type { ReportDataOptions };
 export interface GenerateReportOptions extends ReportDataOptions {
 }

package/dist/core/generateReport/report.js

@@ -43,13 +43,13 @@ exports.generateReport = generateReport;
 exports.reportMain = reportMain;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
-const reportData_1 = require("./reportData");
+const reportData_js_1 = require("./reportData.js");
 /**
  * 报告生成统一入口：数据生成 → 写入 report-data.json
  */
 async function generateReport(opts) {
     // Step 1: 生成报告数据（纯计算，无 IO）
-    const reportData = await (0, reportData_1.generateReportData)(opts);
+    const reportData = await (0, reportData_js_1.generateReportData)(opts);
     // Step 2: 写入 round-N/report-data.json，latest/ 用 symlink 指向最新轮次（避免 34MB+ 重复拷贝）
     const { roundDir, latestDir, summary } = reportData;
     fs.mkdirSync(roundDir, { recursive: true });

package/dist/core/generateReport/reportData.d.ts

@@ -7,6 +7,7 @@
  * This file handles ONLY data processing — no HTML rendering.
  * Rendering is handled by generate-html-renderer.ts.
  */
+import { type RuntimeDiagnostics } from '../../page-agent/diagnostics.js';
 export interface ReportDataOptions {
     projectRoot: string;
     resultsPath: string;
@@ -192,6 +193,8 @@ export interface CaseReportItem {
     errorCategory?: string;
     /** AI 观察到的诊断提示（如 disabled 按钮、SSO 重定向等） */
     diagnosticHint?: string;
+    /** 运行诊断（性能 / 网络 / 浏览器错误 / 质量信号），用例级聚合 */
+    diagnostics?: RuntimeDiagnostics;
 }
 declare function parseCaseIdFromTitle(title: string): string | null;
 declare function parseYamlSimple(yamlText: string): TestCaseYaml;

package/dist/core/generateReport/reportData.js

@@ -54,17 +54,19 @@ exports.buildCaseResultMap = buildCaseResultMap;
 exports.parseYamlSimple = parseYamlSimple;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
-const keve_registry_1 = require("../keve-registry");
+const keve_registry_js_1 = require("../decorator/keve-registry.js");
 function resolveOptions(opts) {
     const PROJECT_ROOT = opts.projectRoot;
     const TEST_RESULTS_JSON = opts.resultsPath;
     const CONFIDENCE_DATA_JSONL = opts.confidencePath || path.join(path.dirname(TEST_RESULTS_JSON), 'confidence-data.jsonl');
     const TEST_CASES_YAML = opts.casesPath || path.join(PROJECT_ROOT, 'test-cases.yaml');
-    // REPORTS_DIR = parent of round-N dirs (e.g. .keve/{plan}/test-artifacts/)
-    // test-results.json is inside round-N dir, so go up one level
-    const RESULT_PARENT_DIR = path.dirname(path.dirname(TEST_RESULTS_JSON));
-    const SCREENSHOTS_DIR = path.join(RESULT_PARENT_DIR, 'screenshots');
-    const REPORTS_DIR = RESULT_PARENT_DIR;
+    // test-results.json 所在目录即当前轮次目录：
+    //   新布局 <taskRoot>/reports/round-N
+    //   旧布局 <taskDir>/test-artifacts/round-N
+    // 因此轮次父目录是 REPORTS_DIR，截图则在轮次目录内部。
+    const ROUND_DIR = path.dirname(TEST_RESULTS_JSON);
+    const SCREENSHOTS_DIR = path.join(ROUND_DIR, 'screenshots');
+    const REPORTS_DIR = path.dirname(ROUND_DIR);
     return { PROJECT_ROOT, TEST_RESULTS_JSON, CONFIDENCE_DATA_JSONL, TEST_CASES_YAML, SCREENSHOTS_DIR, REPORTS_DIR };
 }
 // ─── Helpers ─────────────────────────────────────────────────────
@@ -81,6 +83,18 @@ function parseCaseIdFromTitle(title) {
     const spaceMatch = title.match(new RegExp(`^(${caseIdPattern})\\s`));
     return colonMatch?.[1] || bracketMatch?.[1] || spaceMatch?.[1] || null;
 }
+/**
+ * @keveModel 的模块 ID（describe 标题 `"${id}: ${description}"` 中冒号前的部分）。
+ *
+ * 三种合法形态（与 parseCaseIdFromTitle 的取值域保持一致）：
+ *   1. DSL 转译：`M_SG90061`（含下划线）
+ *   2. 手写/LLM：`AG` / `AG-01` / `SKILL_SHARE-01`（含下划线与短横线）
+ *   3. ktest 原始编号：`7473423`（纯数字）
+ *
+ * 之前这里只认「纯字母 + 短横线」或「纯数字」，导致 DSL 生成的 `M_SG90061` 与
+ * `AG-01` 全部匹配失败、模块名退化成 `default` —— 所有用例在报告里被并成一个分组。
+ */
+const MODULE_ID_PATTERN = '[A-Z][A-Z0-9]*(?:[_-][A-Z0-9]+)*|\\d+';
 /**
  * Strip surrounding quotes from YAML string values.
  * YAML uses quotes like id: "AG-01" which parseYamlSimple captures as "AG-01"
@@ -397,7 +411,7 @@ function buildCaseResultMap(specs, taskDir) {
         const goalScreenshots = parseGoalScreenshots(test.attachments || [], taskDir);
         keveScreenshots.push(...goalScreenshots);
         // keveGoals: prefer @keveGoal decorator data from sceneGoalsMap, fallback to fixture attachment
-        const decoratorGoals = keve_registry_1.sceneGoalsMap.get(spec.title);
+        const decoratorGoals = keve_registry_js_1.sceneGoalsMap.get(spec.title);
         const keveGoals = decoratorGoals && decoratorGoals.length > 0
             ? decoratorGoals
             : parseKeveGoals(test.attachments || []);
@@ -406,7 +420,7 @@ function buildCaseResultMap(specs, taskDir) {
         const pwModuleTitle = suitePathParts.length >= 2 ? suitePathParts[suitePathParts.length - 1].trim() : suitePathParts[0].trim();
         // @keveModel title format: "${id}: ${description}" — extract module ID and description
         // 模块 ID 可能是字母格式（如 AG-01）或 ktest 纯数字格式（如 7473423）
-        const moduleIdMatch = pwModuleTitle.match(/^([A-Z]+(?:-[A-Z]+)*|\d+):\s*(.+)$/);
+        const moduleIdMatch = pwModuleTitle.match(new RegExp(`^(${MODULE_ID_PATTERN}):\\s*(.+)$`));
         const pwModuleId = moduleIdMatch?.[1] || '';
         const pwModuleDescription = moduleIdMatch?.[2] || pwModuleTitle;
         map[caseId] = {
@@ -491,6 +505,7 @@ async function generateReportData(opts) {
                         errorCategory: entry.errorCategory || undefined,
                         diagnosticHint: entry.diagnosticHint || undefined,
                         steps,
+                        diagnostics: entry.diagnostics,
                     };
                 }
             }
@@ -506,6 +521,20 @@ async function generateReportData(opts) {
     // Primary data source: Playwright test-results.json (from @keveModel/@keveScene decorators)
     // Optional enhancement: test-cases.yaml (priority, precondition, type, notes)
     // This ensures decorator-defined structure drives the report, avoiding ID/title mismatch.
+    /** 从已执行步骤提取 Agent 最终结论（done.text），用于补全空 thought。 */
+    function extractFinalConclusion(steps) {
+        for (let i = steps.length - 1; i >= 0; i--) {
+            const actions = steps[i]?.actions;
+            if (!actions?.length)
+                continue;
+            for (let j = actions.length - 1; j >= 0; j--) {
+                const action = actions[j];
+                if (action?.tool === 'done' && action?.text)
+                    return action.text.trim();
+            }
+        }
+        return '';
+    }
     // Build a YAML lookup by caseId for optional enrichment
     const yamlCaseLookup = {};
     const yamlModuleLookup = {};
@@ -521,11 +550,10 @@ async function generateReportData(opts) {
         const effectiveStatus = result.status === 'timedOut' ? 'failed' : result.status;
         // AI evaluation: match by Playwright title (scene.title, the canonical key)
         const aiEntry = aiConfidenceMap[result.title] || aiConfidenceMap[caseId];
-        const data = effectiveStatus === 'skipped' ? '待确认' : (aiEntry?.data || '待确认');
+        const data = effectiveStatus === 'skipped' ? '待确认' : (aiEntry?.data || (effectiveStatus === 'passed' ? '通过' : '待确认'));
         // When aiEntry is missing, confidence should be 0 (no AI evaluation performed),
         // not a hardcoded fallback like 70/35 which implies AI evaluated but was uncertain.
         const confidence = effectiveStatus === 'skipped' ? 0 : (aiEntry?.confidence ?? 0);
-        const confidenceReason = effectiveStatus === 'skipped' ? '用例被跳过' : (aiEntry?.thought || '无AI评估数据');
         // Distribute by data value + confidence
         if (effectiveStatus === 'skipped') { /* skip */ }
         else if (data === '通过')
@@ -599,6 +627,8 @@ async function generateReportData(opts) {
                     expected: g.expected,
                     precondition: g.precondition,
                     order: g.order,
+                    status: effectiveStatus === 'passed' ? 'passed' : (g.success === false ? 'failed' : 'unexecuted'),
+                    success: g.success,
                 }))
                 : []);
         // ── Merge executed steps with YAML outline ──
@@ -617,19 +647,22 @@ async function generateReportData(opts) {
                     continue;
                 if (steps.some(s => s.order === i))
                     continue;
-                // Add unexecuted YAML step
+                // Add unexecuted YAML step — if case passed, mark as passed; otherwise unexecuted
                 steps.push({
                     step: ys.step,
                     expected: ys.expected,
                     order: i,
-                    success: undefined,
-                    // Mark as unexecuted so frontend can render "未执行" state
-                    status: 'unexecuted',
+                    success: effectiveStatus === 'passed' ? true : undefined,
+                    status: effectiveStatus === 'passed' ? 'passed' : 'unexecuted',
                 });
             }
             // Sort by order to ensure correct sequencing
             steps.sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
         }
+        const extractedConclusion = extractFinalConclusion(steps);
+        const confidenceReason = effectiveStatus === 'skipped'
+            ? '用例被跳过'
+            : (aiEntry?.thought || extractedConclusion || '无AI评估数据');
         caseResults.push({
             caseId,
             module: moduleName,
@@ -649,7 +682,7 @@ async function generateReportData(opts) {
             stdout: result.stdout,
             data,
             confidence,
-            thought: aiEntry?.thought || (effectiveStatus === 'skipped' ? '用例被跳过（非自动执行）' : ''),
+            thought: aiEntry?.thought || extractedConclusion || (effectiveStatus === 'skipped' ? '用例被跳过（非自动执行）' : ''),
             confidenceReason,
             stepScreenshots: stepScreenshotsPaths,
             screenshotPath: result.screenshotPath,
@@ -658,6 +691,7 @@ async function generateReportData(opts) {
             keveScreenshots: keveScreenshotsPaths,
             errorCategory: aiEntry?.errorCategory,
             diagnosticHint: aiEntry?.diagnosticHint,
+            diagnostics: aiEntry?.diagnostics,
         });
     }
     // Also include YAML cases that have no matching Playwright result (not executed)