@kkeve/suite 0.0.19 → 0.0.21

package/dist/dsl/index.d.ts

@@ -9,7 +9,7 @@
  * 分层：DB 装载 / 内嵌场景展开 / 元素库 source 跳解析 / 变量表查询全部留在
  * 调用方（见 eve-backend 的 dslLoader）。这里只做纯函数投影。
  */
-export { toDecorator, type DslHop, type DslValue, type DslExpectation, type DslStep, type DslVariableRow, type ToDecoratorOptions, } from './toDecorator.js';
+export { toDecorator, stepExpectedText, type DslHop, type DslValue, type DslExpectation, type DslStep, type DslVariableRow, type ExpectedRenderContext, type ToDecoratorOptions, } from './toDecorator.js';
 /** 语义别名：调用方按「生成一份装饰器 spec」的语义引用时更直观 */
 export { toDecorator as generateDecoratorSpec } from './toDecorator.js';
 export { STEP_OPERATIONS, ASSERT_OPERATIONS, TEXT_ONLY_ASSERT_OPERATIONS, EXPECTED_VALUE_CTYPES, COMPARISON_EXPRESSIONS, isKnownOperation, isKnownAssert, isTextOnlyAssert, parseComparison, type StepOperation, } from './ops.js';

package/dist/dsl/index.js

@@ -11,9 +11,10 @@
  * 调用方（见 eve-backend 的 dslLoader）。这里只做纯函数投影。
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseComparison = exports.isTextOnlyAssert = exports.isKnownAssert = exports.isKnownOperation = exports.COMPARISON_EXPRESSIONS = exports.EXPECTED_VALUE_CTYPES = exports.TEXT_ONLY_ASSERT_OPERATIONS = exports.ASSERT_OPERATIONS = exports.STEP_OPERATIONS = exports.generateDecoratorSpec = exports.toDecorator = void 0;
+exports.parseComparison = exports.isTextOnlyAssert = exports.isKnownAssert = exports.isKnownOperation = exports.COMPARISON_EXPRESSIONS = exports.EXPECTED_VALUE_CTYPES = exports.TEXT_ONLY_ASSERT_OPERATIONS = exports.ASSERT_OPERATIONS = exports.STEP_OPERATIONS = exports.generateDecoratorSpec = exports.stepExpectedText = exports.toDecorator = void 0;
 var toDecorator_js_1 = require("./toDecorator.js");
 Object.defineProperty(exports, "toDecorator", { enumerable: true, get: function () { return toDecorator_js_1.toDecorator; } });
+Object.defineProperty(exports, "stepExpectedText", { enumerable: true, get: function () { return toDecorator_js_1.stepExpectedText; } });
 /** 语义别名：调用方按「生成一份装饰器 spec」的语义引用时更直观 */
 var toDecorator_js_2 = require("./toDecorator.js");
 Object.defineProperty(exports, "generateDecoratorSpec", { enumerable: true, get: function () { return toDecorator_js_2.toDecorator; } });

package/dist/dsl/toDecorator.d.ts

@@ -96,3 +96,20 @@ export interface ToDecoratorOptions {
 }
 /** 生成装饰器脚本源码（UTF-8 文本） */
 export declare function toDecorator(options: ToDecoratorOptions): string;
+/** 计算 expected 文案所需的最小上下文（与脚本投影共用，保证报告与脚本同文案） */
+export interface ExpectedRenderContext {
+    env: string;
+    variableList?: DslVariableRow[];
+    account?: {
+        name: string;
+        password: string;
+    };
+}
+/**
+ * 步骤 expected 文案的**公开**入口。
+ *
+ * 投影脚本（toDecorator）与报告 outline（run-dsl-task / report-data）必须产出
+ * 同一份文案，否则会出现「报告的预期」与「评测 Agent 看到的预期」不一致 ——
+ * 那正是「报错4」这类标签被当成字面量去页面搜索的根因。调用方统一走这里。
+ */
+export declare function stepExpectedText(step: DslStep, ctx: ExpectedRenderContext): string;

package/dist/dsl/toDecorator.js

@@ -21,6 +21,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toDecorator = toDecorator;
+exports.stepExpectedText = stepExpectedText;
 const ops_js_1 = require("./ops.js");
 // ─── 生成入口 ────────────────────────────────────────────────────────
 /** 生成装饰器脚本源码（UTF-8 文本） */
@@ -96,8 +97,7 @@ function renderStep(d, ctx) {
     }
     const out = [];
     const stepText = String(d.text || op);
-    const expTexts = (d.expectation || []).map((e) => String(e.text || '')).filter(Boolean);
-    const expected = expTexts.length ? expTexts.join('；') : '操作完成，页面正常响应';
+    const expected = expectedTextOf(d.expectation || [], (e) => resolveExpectationValue(e, ctx));
     const chain = chainExpr(d.context);
     const expLines = [];
     for (const e of d.expectation || []) {
@@ -106,7 +106,7 @@ function renderStep(d, ctx) {
             expLines.push(a);
     }
     const emit = (body) => {
-        out.push(`await keveGoal({ step: ${q(stepText)}, expected: ${q(expected)}${reactOption(d)} }, async () => {`);
+        out.push(`await keveGoal({ step: ${q(stepText)}, expected: ${q(expected)} }, async () => {`);
         for (const b of [...body, ...expLines])
             out.push(`  ${b}`);
         out.push(`});`);
@@ -232,7 +232,7 @@ function renderStep(d, ctx) {
             // 区域截图容错：元素不在当前页面（权限阻断等）时降级为整页截图，
             // 是否一致由基线比对决定，截图本身不做权限硬门。
             if (shotChain) {
-                out.push(`await keveGoal({ step: ${q(stepText)}, expected: ${q(expected)}${reactOption(d)} }, async () => {`);
+                out.push(`await keveGoal({ step: ${q(stepText)}, expected: ${q(expected)} }, async () => {`);
                 out.push(`  try {`);
                 out.push(`    await engine.screenshot(${q(shotName)}, ${shotChain});`);
                 out.push(`  } catch (_shotErr: any) {`);
@@ -275,7 +275,8 @@ function renderOpenPageWithGates(d, gates, ctx) {
     const stepText = String(d.text || 'OPEN_PAGE');
     const gateTexts = gates.map((g) => String(g.text || '')).filter(Boolean);
     const gateExpects = gates
-        .flatMap((g) => (g.expectation || []).map((e) => String(e.text || '')))
+        .filter((g) => (g.expectation || []).length > 0)
+        .map((g) => expectedTextOf(g.expectation || [], (e) => resolveExpectationValue(e, ctx)))
         .filter(Boolean);
     const expected = [...gateTexts, ...gateExpects].filter(Boolean).join('；') || '打开目标页面并等待就绪响应';
     const resolved = resolveOpenPage(d, ctx);
@@ -299,51 +300,143 @@ function renderOpenPageWithGates(d, gates, ctx) {
                 body.push(`await __gate${gi}; // 等 ${String(g.text || '就绪响应')}`);
         });
     }
-    out.push(`await keveGoal({ step: ${q(stepText)}, expected: ${q(expected)}${reactOption(d)} }, async () => {`);
+    out.push(`await keveGoal({ step: ${q(stepText)}, expected: ${q(expected)} }, async () => {`);
     for (const b of body)
         out.push(`  ${b}`);
     out.push(`});`);
     return out;
 }
-// ─── 断言转译 ────────────────────────────────────────────────────────
 /**
- * 步骤是否只有「纯文案期望」，必须依赖 LLM 才能判定。
+ * 步骤 expected 文案的**公开**入口。
  *
- * 平台 DSL 里有两类 expectation：
- *  - 可执行断言（ELEMENT_NOT_EXIST / TEXT_EXIST …）→ 转译成 engine 断言，
- *    成败在脚本里已经确定，无需再看页面；
- *  - 纯文案载体（TEXT / 无 type）→ 不产生任何断言，只以文字描述预期，
- *    脚本无法自证，只能交给 Agent 观察页面后判定。
+ * 投影脚本（toDecorator）与报告 outline（run-dsl-task / report-data）必须产出
+ * 同一份文案，否则会出现「报告的预期」与「评测 Agent 看到的预期」不一致 ——
+ * 那正是「报错4」这类标签被当成字面量去页面搜索的根因。调用方统一走这里。
+ */
+function stepExpectedText(step, ctx) {
+    const renderCtx = {
+        env: ctx.env,
+        variableList: ctx.variableList || [],
+        account: ctx.account,
+    };
+    return expectedTextOf(step.expectation || [], (e) => resolveExpectationValue(e, renderCtx));
+}
+/**
+ * 步骤的 expected 文案 —— 喂给评测 Agent 判断「预期是否真的达成」。
+ *
+ * 平台 expectation[].text 常常只是录制期标签（「报错1」「报错4」），不携带
+ * 任何可判定语义；真实预期藏在同一条 expectation 的 type + value + context 里
+ * （如 ELEMENT_NOT_EXIST + includes「业务逻辑错误」= 页面不应出现该错误）。
+ * 只把标签交给评测 Agent，它会去页面上找字面量「报错4」并据此误判失败。
  *
- * 只有第二类（且该步骤没有可执行断言）才需要保留 Agent Re-Act。
+ * 因此按「可执行断言语义优先、标签作为备注」组装：
+ *   - 有可执行断言 → 渲染成人话（页面不存在包含「业务逻辑错误」的内容）；
+ *   - 纯文案载体（TEXT / 无 type）→ 标签本身就是人话，直接采用；
+ *   - 一个断言都渲染不出来时，退回平台标签，最后兜底为通用文案。
  */
-function needsAgentJudge(d) {
-    const expects = d.expectation || [];
-    if (!expects.length)
-        return false;
-    const hasExecutable = expects.some((e) => {
+function expectedTextOf(expectations, resolveValue) {
+    const semantic = [];
+    const labelOnly = [];
+    for (const e of expectations) {
+        const label = String(e.text || '').trim();
         const type = String(e.type || '');
-        return type && !(0, ops_js_1.isTextOnlyAssert)(type);
-    });
-    if (hasExecutable)
-        return false;
-    return expects.some((e) => {
-        const type = String(e.type || '');
-        return !type || (0, ops_js_1.isTextOnlyAssert)(type);
+        if (!type || (0, ops_js_1.isTextOnlyAssert)(type)) {
+            if (label)
+                labelOnly.push(label);
+            continue;
+        }
+        const phrase = describeExpectation(e, resolveValue(e));
+        // 未知断言在 renderExpectation 里会确定性报错；这里不能让 expected 抢先崩，
+        // 退化成标签即可，真正的失败由断言渲染抛出。
+        if (phrase)
+            semantic.push(label && !phrase.includes(label) ? `${phrase}（${label}）` : phrase);
+        else if (label)
+            labelOnly.push(label);
+    }
+    const parts = [...semantic, ...labelOnly].filter(Boolean);
+    return parts.length ? parts.join('；') : '操作完成，页面正常响应';
+}
+/** 单条可执行断言 → 人类可读预期；返回 null 表示无法给出语义（由调用方兜底） */
+function describeExpectation(e, val) {
+    const type = String(e.type || '');
+    const target = describeChain(e.context);
+    const value = String(val ?? '');
+    switch (type) {
+        case 'ELEMENT_EXIST':
+            return `页面存在${target}`;
+        case 'ELEMENT_NOT_EXIST':
+            return `页面不存在${target}`;
+        case 'ELEMENT_VISIBLE':
+            return `${target}可见`;
+        case 'ELEMENT_NOT_VISIBLE':
+            return `${target}不可见`;
+        case 'TEXT_EXIST':
+            if (isPageTitleAssertion(e))
+                return `页面标题包含「${value}」`;
+            return `页面存在包含「${value}」的内容${target}`;
+        case 'TEXT_NOT_EXIST':
+            if (!value.trim())
+                return null;
+            return `页面不存在包含「${value}」的内容${target}`;
+        case 'TEXT_EQUAL':
+            return `元素${target}文本等于「${value}」`;
+        case 'EXPECTED_VALUE': {
+            const ctype = String(e.ctype || 'text').toLowerCase();
+            const { mode, negated } = (0, ops_js_1.parseComparison)(String(e.cexpression || 'include'));
+            const dim = { text: '文本', class: '类名', placeholder: '占位提示', style: '样式', index: '元素个数' }[ctype] || ctype;
+            if (ctype === 'index')
+                return `元素${target}个数等于 ${value}`;
+            const op = mode === 'eq' ? (negated ? '不等于' : '等于') : (negated ? '不包含' : '包含');
+            return `元素${target}的${dim}${op}「${value}」`;
+        }
+        case 'EXPECTED__PAGET_VALUE': {
+            const ctype = String(e.ctype || 'url').toLowerCase();
+            const { mode, negated } = (0, ops_js_1.parseComparison)(String(e.cexpression || 'eq'));
+            const dim = ctype === 'title' ? '标题' : '地址';
+            const op = mode === 'eq' ? (negated ? '不等于' : '等于') : (negated ? '不包含' : '包含');
+            return `页面${dim}${op}「${value}」`;
+        }
+        case 'SCREEN_SHOT_COMPARE':
+        case 'SCREENSHOT_COMPARE':
+        case 'IMAGE_COMPARE':
+            return `页面截图与基线「${value || e.text || ''}」一致`;
+        default:
+            return null;
+    }
+}
+/** 定位链 → 人类可读描述（评测 Agent 据此知道「在哪个区域」观察） */
+function describeChain(context) {
+    let hops;
+    try {
+        hops = collectHops(context);
+    }
+    catch {
+        return '';
+    }
+    if (!hops.length)
+        return '';
+    // 单跳文本包含：平台最常见的「页面不应出现某文案」录制形态
+    if (hops.length === 1 && (hops[0].type === 'includes' || hops[0].type === 'text')) {
+        return `包含「${hops[0].value.trim()}」的元素`;
+    }
+    const parts = hops.map((h) => {
+        const text = h.value.trim();
+        if (h.type === 'includes' || h.type === 'text')
+            return `包含「${text}」`;
+        if (h.type === 'selector')
+            return `选择器「${text}」`;
+        return `${h.type}=「${text}」`;
     });
+    return `（${parts.join(' → ')}）`;
 }
 /**
- * keveGoal 的 react 参数片段。
+ * 渲染一条 expectation 为 engine 断言；返回 null 表示「纯文案载体，不产生断言」。
  *
- * 平台 DSL 是确定性录制产物：凡能自证的步骤都显式 react: false，跳过 Agent
- * Re-Act —— 否则每个步骤都会额外发起一轮 LLM 探索，既拖长整体耗时至超出
- * Cypress 用例超时（表现为「任务卡住」），也会让「报错1」这类仅作平台标签的
- * expected 文案参与最终结论。
+ * 注意投影脚本**不输出 `react: false`**：可执行断言只证明预期的一个子集，
+ * fn 执行成功不等于 expected 已达成，所以每个 goal 都保留评测阶段 —— Agent
+ * 先观察真实页面评测，达成即放行，未达成再继续探索；断言失败由引擎侧统一
+ * 参与终局覆盖，不允许被评审判成 pass。
  */
-function reactOption(d) {
-    return needsAgentJudge(d) ? '' : ', react: false';
-}
-/** 渲染一条 expectation；返回 null 表示「纯文案载体，不产生断言」 */
 function renderExpectation(e, ctx) {
     const type = String(e.type || '');
     // 无 type / TEXT：纯「期望文案」载体，只喂 keveGoal.expected，不是断言

package/dist/engine-cypress/bridge.js

@@ -55,6 +55,82 @@ const path = __importStar(require("node:path"));
 const screenshotDiff_js_1 = require("../core/judge/screenshotDiff.js");
 const confidence_js_1 = require("../core/judge/confidence.js");
 const reportData_js_1 = require("../core/generateReport/reportData.js");
+/** Cypress 最终状态 → 报告状态；pending 明确是跳过，其余非 passed 均按失败处理 */
+function mapCypressState(rawState) {
+    const state = String(rawState || '').toLowerCase();
+    if (state === 'passed')
+        return 'passed';
+    if (state === 'pending' || state === 'skipped')
+        return 'skipped';
+    if (state === 'timedout' || state === 'timed_out')
+        return 'timedOut';
+    return 'failed';
+}
+/** 从 Cypress after:spec / after:run 的 TestResult 提取开始时间与耗时 */
+function timingOfCypressTest(test) {
+    const attempts = Array.isArray(test?.attempts) ? test.attempts : [];
+    const last = attempts[attempts.length - 1] || {};
+    const duration = Number(last.wallClockDuration ?? test?.duration ?? 0);
+    const startedAt = last.wallClockStartedAt || test?.wallClockStartedAt;
+    if (startedAt) {
+        const parsed = new Date(startedAt);
+        if (!Number.isNaN(parsed.getTime()))
+            return { duration, startTime: parsed.toISOString() };
+    }
+    return { duration, startTime: new Date(Date.now() - (Number.isFinite(duration) ? duration : 0)).toISOString() };
+}
+/**
+ * 用 Cypress 引擎掌握的最终测试结果补录 / 校正状态。
+ *
+ * 浏览器侧 `/report/test` 依赖全局 afterEach 与场景状态；beforeEach 等钩子
+ * 直接失败时状态可能拿不到，导致用例没有任何上报，最终被 reportData 补成
+ * `missing`。Cypress 的 after:spec / after:run 仍能提供权威结果，这里是唯一
+ * 不依赖用例内钩子的兜底入口。
+ */
+function mergeCypressRunTests(state, tests, specFile = '') {
+    let merged = 0;
+    for (const test of Array.isArray(tests) ? tests : []) {
+        const titlePath = Array.isArray(test?.title) ? test.title.map((part) => String(part)) : [];
+        const title = (titlePath[titlePath.length - 1] || String(test?.title || '')).trim();
+        if (!title)
+            continue;
+        const suiteTitle = titlePath.length >= 2 ? String(titlePath[titlePath.length - 2] || '').trim() : '';
+        const status = mapCypressState(test?.state);
+        const { duration, startTime } = timingOfCypressTest(test);
+        const error = status === 'passed' || status === 'skipped'
+            ? undefined
+            : String(test?.displayError || test?.attempts?.[test.attempts.length - 1]?.error?.message || '');
+        const existing = state.results.find((r) => r.title === title && (!specFile || !r.file || r.file === specFile));
+        if (existing) {
+            // Cypress 的最终状态优先于浏览器侧可能拿到的中间状态；日志与附件保留。
+            existing.status = status;
+            existing.duration = duration || existing.duration;
+            existing.startTime = startTime || existing.startTime;
+            // Cypress 最终结论权威：失败才写错误，最终 passed/skipped 必须清掉
+            // 浏览器侧中间状态可能留下的误报错误，避免报告出现「通过但带错误」。
+            existing.error = error;
+            if (!existing.suiteTitle && suiteTitle)
+                existing.suiteTitle = suiteTitle;
+            if (!existing.file && specFile)
+                existing.file = specFile;
+        }
+        else {
+            state.results.push({
+                title,
+                suiteTitle,
+                file: specFile,
+                status,
+                duration,
+                startTime,
+                error,
+                logs: [],
+                attachments: [],
+            });
+        }
+        merged++;
+    }
+    return merged;
+}
 function resultDirOf() {
     // 优先使用 runner 注入的报告目录；缺失时回退旧布局，兼容历史执行环境。
     if (process.env.KEVE_RESULT_DIR)
@@ -300,7 +376,10 @@ async function setupKeveBridge(on, config) {
             }
             catch { /* 软链失败不影响报告生成 */ }
         }
-        return { ok: true, resultsPath, reportDataPath, cases: reportData?.summary?.total ?? undefined };
+        // reportData.summary 是 summaryJson 本体，total 在其嵌套的 summary 字段下。
+        // 直接读 summary.total 恒为 undefined，日志会误报「用例 0」，掩盖真实用例数。
+        const cases = reportData?.summary?.summary?.total ?? reportData?.summary?.total;
+        return { ok: true, resultsPath, reportDataPath, cases: cases ?? undefined };
     };
     const handle = async (route, payload, signal) => {
         switch (route) {
@@ -551,8 +630,15 @@ async function setupKeveBridge(on, config) {
     console.log(`[keve-bridge] listening on 127.0.0.1:${port} → ${state.resultDir}`);
     // 报告收口放在 after:run：此时所有 spec 的 /report/test 都已落盘，
     // 且不依赖任何场景级的 afterAll（硬失败/中断也能出报告）。
-    on('after:run', async () => {
+    on('after:run', async (runResults) => {
         try {
+            // 最后一次用 Cypress run 全量结果校正，防止个别 spec 的 after:spec 未触发。
+            let merged = 0;
+            for (const run of Array.isArray(runResults?.runs) ? runResults.runs : []) {
+                merged += mergeCypressRunTests(state, run?.tests || [], String(run?.spec?.relative || ''));
+            }
+            if (merged > 0)
+                console.log(`[keve-bridge] Cypress 最终结果校正 ${merged} 条`);
             const out = await finalize();
             console.log(`[keve-bridge] report-data.json → ${out.reportDataPath}（用例 ${out.cases ?? 0}）`);
         }
@@ -572,6 +658,9 @@ async function setupKeveBridge(on, config) {
      * after:spec 早于 after:run 触发，此时 results 已由浏览器侧 /report/test 落盘。
      */
     on('after:spec', async (_spec, results) => {
+        const merged = mergeCypressRunTests(state, results?.tests || [], String(results?.spec?.relative || ''));
+        if (merged > 0)
+            console.log(`[keve-bridge] Cypress 用例结果校正 ${merged} 条`);
         const video = results?.video;
         if (video && fs.existsSync(video)) {
             // 相对 taskDir，与 Playwright 侧 videoPath 的语义一致

package/dist/engine-cypress/keveGoal.d.ts

@@ -17,16 +17,6 @@ export interface KeveGoalCallOptions {
     precondition?: string;
     step: string;
     expected: string;
-    /**
-     * 是否在 fn 之后追加一轮 Agent Re-Act 做最终判定。
-     *
-     * 默认 true（AI 场景 / 手写用例）：fn 只是前置动作与确定性校验，预期是否真正
-     * 达成由 Agent 观察真实页面后判定。
-     *
-     * DSL 投影脚本会显式传 false：整条链路的判定已由确定性断言给出，Re-Act 只会
-     * 额外消耗 LLM 预算，并让「报错1」这类平台标签参与结论。
-     */
-    react?: boolean;
 }
 /** agent Re-Act 的结果（P0-3 接入；未接入时由 fn 结果直接判定） */
 export interface CyGoalExploreResult {

package/dist/engine-cypress/keveGoal.js

@@ -75,7 +75,6 @@ function createCyKeveGoal(engine) {
         let fnErrorRaw;
         let fnResult;
         let fnBlocked = false;
-        const reactEnabled = options.react !== false;
         const fnSource = fn?.toString() || undefined;
         const owned = !(0, shotBuffer_js_1.isGoalShotDiffCaptureActive)();
         if (owned)
@@ -140,31 +139,12 @@ function createCyKeveGoal(engine) {
             };
             console.log(`[keveGoal] 📊 "${options.step}" 截图差异超阈值 — 确定性失败`);
         }
-        else if (!reactEnabled) {
-            // 确定性模式：断言是否通过就是结论，不再发起 LLM 探索。
-            reactResult = {
-                expectedMet: !fnError,
-                conclusion: fnError ? 'fail' : 'pass',
-                actions: [{
-                        action: {
-                            tool: 'done',
-                            verdict: fnError ? 'fail' : 'pass',
-                            text: fnError ? `Assertion failed: ${fnError}` : '确定性断言全部通过',
-                        },
-                        toolOutput: '',
-                        result: 'ok',
-                    }],
-                agentScreenshots: [],
-            };
-            logLine(fnError
-                ? `[keveGoal] ⚙️ "${options.step}" 确定性模式：fn 失败，跳过 Agent Re-Act`
-                : `[keveGoal] ⚙️ "${options.step}" 确定性模式：fn 通过，跳过 Agent Re-Act`);
-        }
         else {
-            // fn 成功 / 失败都交给探索器（若引擎入口注册了 AI Re-Act）。
-            // fn 只是前置确定性校验，@keveGoal 的预期是否真正达成必须由 Agent
-            // 观察真实页面后给出最终结论 —— 即便 fn 已通过，也要产出推理轨迹与
-            // 执行后截图，否则报告里会缺少 AI 推理日志。
+            // fn 成功 / 失败都交给评测器。fn 只是前置动作与确定性校验：
+            //  - fn 成功 ≠ expected 达成（fn 可能只覆盖预期的一个子集）；
+            //  - fn 失败 ≠ 不可恢复（普通运行时错误下页面可能仍可探索自愈）。
+            // 「先评测、再决定放行还是探索」由这一轮承担：Agent 先观察真实页面评测
+            // expected，达成即 done(pass) 放行，未达成再继续探索。
             let explored;
             if (explorer) {
                 try {

package/dist/engine-playwright/keve-test.d.ts

@@ -32,13 +32,6 @@ export interface KeveGoalCallOptions {
     precondition?: string;
     step: string;
     expected: string;
-    /**
-     * 是否在 fn 之后追加一轮 Agent Re-Act 做最终判定。
-     *
-     * 默认 true（AI 场景 / 手写用例）；DSL 投影脚本传 false，判定完全由确定性
-     * 断言给出，避免为每个步骤额外消耗一轮 LLM。
-     */
-    react?: boolean;
 }
 type KeveFixture = {
     keveGoal: (options: KeveGoalCallOptions, fn?: () => Promise<void>) => Promise<void>;

package/dist/engine-playwright/keve-test.js

@@ -189,7 +189,6 @@ exports.test = test_1.test.extend({
             let fnErrorRaw; // 原始错误对象（ScreenshotDiffError 等带结构的错误需要保留结构）
             let fnResult; // fn 返回值透传（flow 产物，如 createDashboard 的看板名）
             let fnBlocked = false; // true when fn error is environment-blocked (skip agent Re-Act)
-            const reactEnabled = options.react !== false;
             // 截图对比：fn 前开缓冲、fn 后收集 —— engine.expectScreenshot 的结果经此进 attachment
             (0, screenshotDiff_js_1.beginGoalShotDiffCapture)();
             if (fn) {
@@ -298,27 +297,6 @@ exports.test = test_1.test.extend({
                         conclusion: 'fail',
                     };
                 }
-                else if (!reactEnabled) {
-                    // 确定性模式（DSL 投影脚本）：断言结果即结论，不再发起 LLM 探索。
-                    console.log(fnError
-                        ? `[keveGoal] ⚙️ "${options.step}" deterministic mode: fn failed — skipping agent Re-Act`
-                        : `[keveGoal] ⚙️ "${options.step}" deterministic mode: fn passed — skipping agent Re-Act`);
-                    reactResult = {
-                        expectedMet: !fnError,
-                        actions: [{
-                                action: {
-                                    tool: 'done',
-                                    verdict: fnError ? 'fail' : 'pass',
-                                    text: fnError ? `Assertion failed: ${fnError}` : '确定性断言全部通过',
-                                },
-                                toolOutput: '',
-                                result: 'ok',
-                            }],
-                        finalSnapshot: '',
-                        agentScreenshots: [],
-                        conclusion: fnError ? 'fail' : 'pass',
-                    };
-                }
                 else {
                     // ── Per-goal timeout: prevent one slow goal from exhausting the test timeout ──
                     // Default 300s per goal; total test timeout should be ≥ (goals × 300s + overhead)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kkeve/suite",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "description": "AI-powered full-stack test agent CLI - static analysis, unit test, component test, E2E test, execute, evaluate, and report",
   "license": "MIT",
   "bin": {

package/scripts/run-dsl-task.mjs

@@ -134,8 +134,12 @@ function normalizeStep(step) {
  * 投影 DSL 步骤为报告 outline，语义与 toDecorator 的 keveGoal 参数保持一致。
  * OPEN_PAGE 后紧跟的 WAIT_RESPONSE 会合并进同一个导航步骤，避免报告步骤数
  * 与脚本实际 keveGoal 数不一致。
+ *
+ * expected 文案统一走 stepExpectedText（与脚本投影同一个函数）：报告里展示的
+ * 预期与评测 Agent 读到的预期必须逐字一致，否则平台标签（「报错4」）会在报告
+ * 与评测两侧产生不同解读。
  */
-function buildCaseSteps(dslList) {
+function buildCaseSteps(dslList, ctx, stepExpectedText) {
   const steps = [];
   for (let i = 0; i < dslList.length; i++) {
     const d = dslList[i];
@@ -149,7 +153,8 @@ function buildCaseSteps(dslList) {
       if (gates.length) {
         const gateTexts = gates.map((g) => String(g?.text || '')).filter(Boolean);
         const gateExpects = gates
-          .flatMap((g) => (g?.expectation || []).map((e) => String(e?.text || '')))
+          .filter((g) => (g?.expectation || []).length > 0)
+          .map((g) => stepExpectedText(g, ctx))
           .filter(Boolean);
         steps.push({
           step: String(d?.text || 'OPEN_PAGE'),
@@ -160,8 +165,7 @@ function buildCaseSteps(dslList) {
       }
     }
     const stepText = String(d?.text || op || '');
-    const expTexts = (d?.expectation || []).map((e) => String(e?.text || '')).filter(Boolean);
-    const expected = expTexts.length ? expTexts.join('；') : '操作完成，页面正常响应';
+    const expected = stepExpectedText(d, ctx);
     if (!stepText) continue;
     steps.push({ step: stepText, expected });
   }
@@ -217,7 +221,7 @@ async function main() {
   fs.rmSync(resultFile, { force: true });
   fs.rmSync(manifestFile, { force: true });
 
-  const { toDecorator } = await import(
+  const { toDecorator, stepExpectedText } = await import(
     url.pathToFileURL(path.join(suiteRoot, 'dist/dsl/index.js')).href
   );
 
@@ -233,20 +237,26 @@ async function main() {
     const importFrom = engine === 'cypress'
       ? '@kkeve/suite/engine-cypress'
       : '@kkeve/suite/keve-test';
+    const account = resolveAccount(item.accountInfo || input.accountInfo);
+    const renderCtx = {
+      env: input.env || 'test',
+      variableList: Array.isArray(item.variableList) ? item.variableList : [],
+      account,
+    };
     const code = toDecorator({
       stepGroupId,
       caseName: item.caseName || `用例 ${stepGroupId}`,
       dslList,
-      env: input.env || 'test',
-      variableList: Array.isArray(item.variableList) ? item.variableList : [],
-      account: resolveAccount(item.accountInfo || input.accountInfo),
+      env: renderCtx.env,
+      variableList: renderCtx.variableList,
+      account: renderCtx.account,
       ssoInject: input.ssoInject !== false,
       importFrom,
     });
 
     const fileName = `sg${stepGroupId}.spec.ts`;
     fs.writeFileSync(path.join(specDir, fileName), code, 'utf-8');
-    const dslSteps = buildCaseSteps(dslList);
+    const dslSteps = buildCaseSteps(dslList, renderCtx, stepExpectedText);
     caseEntries.push({
       caseId: `S${stepGroupId}`,
       stepGroupId,
@@ -540,15 +550,17 @@ function rewriteOpenPageTargets(input, cases) {
 
 /**
  * 逐条统计 caseResults 状态。
- * 状态语义与 core/generateReport 保持一致：
- *   passed / failed 之外的一律按 skipped 计入，保证 total = passed + failed + skipped。
+ *
+ * 只有显式 `skipped` 才算跳过；`missing` / `timedOut` / `unknown` / `error`
+ * 都代表用例没有得到有效执行结果或执行异常，必须计为失败。历史实现把它们
+ * 统一算成 skipped，导致 Cypress 已报 `1 failed` 时平台仍展示 0 失败。
  */
 function summarizeReport(reportData) {
   const cases = Array.isArray(reportData?.caseResults) ? reportData.caseResults : [];
   if (cases.length) {
     const passed = cases.filter((item) => item?.status === 'passed').length;
-    const failed = cases.filter((item) => item?.status === 'failed').length;
-    const skipped = cases.length - passed - failed;
+    const skipped = cases.filter((item) => item?.status === 'skipped').length;
+    const failed = cases.length - passed - skipped;
     return { passed, failed, skipped, total: cases.length };
   }
   const summary = reportData?.summary?.summary || reportData?.summary || {};