@kkeve/suite 0.0.22 → 0.0.23

package/dist/engine-cypress/adapter.js

@@ -94,7 +94,7 @@ class CypressEngine {
      * 导航会销毁注入，所以这里每次校验 `__keveOpsSource` 版本号（幂等且极廉价）。
      */
     async ensureReady() {
-        const has = await this.cdp.evaluateInAut('Boolean(window.__keveOpsSource === "v1" && window.__keveNetLogSource === "v1" && window.__keveLocatorSource === "v1")').catch(() => false);
+        const has = await this.cdp.evaluateInAut('Boolean(window.__keveOpsSource === "v7" && window.__keveNetLogSource === "v1" && window.__keveLocatorSource === "v5")').catch(() => false);
         if (has)
             return;
         const { locatorSource } = await Promise.resolve().then(() => __importStar(require('../dsl/locatorSource.js')));
@@ -209,11 +209,15 @@ class CypressEngine {
     // ── 交互 ─────────────────────────────────────────────────────────
     async click(...refs) {
         const r = normalizeRefs(refs);
-        await this.withWait(() => this.opsCall('click', r, false));
+        // 默认 10s 重试窗口在 wujie 微前端嵌套页面下不够：实测弹层级联渲染（cascader
+        // menu 等）可能被主线程长任务挤到 10s 外才出现，click 命中前的定位重试因此
+        // 提前耗尽，fn 抛错掉进 Agent Re-Act 并在 120s 后被判 blocked（参见 S699
+        // 线上用例排查，task-local-699-*）。这里放宽到 20s，只影响 click/dblClick。
+        await this.withWait(() => this.opsCall('click', r, false), 20000);
     }
     async dblClick(...refs) {
         const r = normalizeRefs(refs);
-        await this.withWait(() => this.opsCall('click', r, true));
+        await this.withWait(() => this.opsCall('click', r, true), 20000);
     }
     /** 强制点击：CDP 下没有 actionability 检查，语义等同于 click */
     async forceClick(...refs) {
@@ -358,6 +362,22 @@ class CypressEngine {
             }
         });
     }
+    /**
+     * 表单元素当前值断言（input/textarea/select 的 value）。
+     *
+     * 与 expectTextEquals 的区别是取值口径：input 的 textContent 恒为空，
+     * 用文本断言校验用户输入会永远失败；这里读 DOM value，才是「输入框里
+     * 确实有这个值」的证据。
+     */
+    async expectValue(expected, ...refs) {
+        const r = normalizeRefs(refs);
+        await this.withWait(async () => {
+            const actual = await this.opsCall('value', r);
+            if (actual !== String(expected)) {
+                throw new Error(`断言失败：元素值应等于「${expected}」，实际为「${actual}」`);
+            }
+        });
+    }
     async expectCount(count, ...refs) {
         const r = normalizeRefs(refs);
         await this.withWait(async () => {

package/dist/engine-cypress/agent-page.js

@@ -305,7 +305,7 @@ class CyAgentPage {
     // ── 页内 agent 能力注入 ────────────────────────────────────────────
     async ensureAgent() {
         const ready = await this.cdp
-            .evaluateInAut('Boolean(window.__keveAgentSource === "v1")')
+            .evaluateInAut('Boolean(window.__keveAgentSource === "v7")')
             .catch(() => false);
         if (ready)
             return;

package/dist/engine-cypress/agentDom.js

@@ -24,7 +24,7 @@ exports.agentBootstrapSource = agentBootstrapSource;
 function agentDomSource() {
     return `(() => {
   "use strict";
-  if (window.__keveAgentSource === "v1") return "cached";
+  if (window.__keveAgentSource === "v7") return "cached";
 
   var MAX_NAME = 120;
   var MAX_LINES = 1500;
@@ -141,7 +141,16 @@ function agentDomSource() {
   }
 
   function allText(el) {
-    return String(el.textContent || "").replace(/\\s+/g, " ").trim();
+    return normalizeText(el.textContent);
+  }
+
+  /** 归一化用于文本匹配的句子：统一空白与半/全角标点，并忽略成对的中文引号装饰 */
+  function normalizeText(str) {
+    return String(str == null ? "" : str)
+      .normalize("NFKC")
+      .replace(/[「」『』【】《》“”‘’]/g, "")
+      .replace(/\\s+/g, " ")
+      .trim();
   }
 
   function isVisible(el) {
@@ -320,7 +329,7 @@ function agentDomSource() {
 
   /** 文本匹配取「包含该文本的最深元素」，与 locatorSource 的 includes 跳一致 */
   function textIn(scopes, needle, exact) {
-    var want = String(needle == null ? "" : needle).replace(/\\s+/g, " ").trim();
+    var want = normalizeText(needle);
     if (!want) return [];
     var hits = [];
     for (var s = 0; s < scopes.length; s += 1) {
@@ -329,19 +338,46 @@ function agentDomSource() {
         ? queryAllDeep(document, "*")
         : queryAllDeep(scope, "*");
       var local = [];
+      // 与 locatorSource 的 includes/text 一致：scope 自身也可直挂目标文本
+      if (scope !== document) {
+        var selfText = allText(scope);
+        if (selfText && (exact ? selfText === want : selfText.indexOf(want) >= 0)) local.push(scope);
+      }
       for (var i = 0; i < pool.length; i += 1) {
         var text = allText(pool[i]);
         if (!text) continue;
         if (exact ? text === want : text.indexOf(want) >= 0) local.push(pool[i]);
       }
+      var outer = [];
       for (var j = 0; j < local.length; j += 1) {
         var el = local[j];
         var hasInnerMatch = false;
         for (var k = 0; k < local.length; k += 1) {
           if (k !== j && el.contains(local[k])) { hasInnerMatch = true; break; }
         }
-        if (!hasInnerMatch) hits.push(el);
+        if (!hasInnerMatch) outer.push(el);
       }
+      if (!outer.length) continue;
+      // 与 locatorSource 保持一致：优先可见且未禁用的最深元素，
+      // 否则回退全部命中，避免隐藏弹窗中的禁用按钮抢走 text 命中。
+      var visible = outer.filter(function (el) {
+        if (el.disabled) return false;
+        try {
+          var style = window.getComputedStyle(el);
+          if (style.display === "none" || style.visibility === "hidden" || Number(style.opacity) === 0) return false;
+          var rect = el.getBoundingClientRect();
+          if (rect.width === 0 && rect.height === 0) return false;
+        } catch (e) { /* enable fallback */ }
+        return true;
+      });
+      var pool = visible.length ? visible : outer;
+      var deepest = pool[0], maxDepth = -1;
+      for (var p = 0; p < pool.length; p += 1) {
+        var dd = 0, cur = pool[p];
+        while (cur && cur.parentElement) { dd += 1; cur = cur.parentElement; }
+        if (dd > maxDepth) { maxDepth = dd; deepest = pool[p]; }
+      }
+      hits.push(deepest);
     }
     return dedupe(hits);
   }
@@ -437,14 +473,37 @@ function agentDomSource() {
     el.dispatchEvent(new MouseEvent(type, base));
   }
 
+  /** 对应 pageOps.dragTapTarget：KwaiBI v-drag-no-tap 要求点中 c-toolbar-item */
+  function dragTapTarget(el) {
+    if (!el) return null;
+    var cur = el.nodeType === 1 ? el : (el.parentElement || null);
+    while (cur) {
+      var cls = String(cur.getAttribute && cur.getAttribute("class") || "");
+      if (cls.indexOf("c-toolbar-item") >= 0) return cur;
+      cur = cur.parentElement;
+    }
+    if (el.nodeType === 1 && el.querySelector) {
+      var found = el.querySelector(".c-toolbar-item");
+      if (found) return found;
+    }
+    return null;
+  }
+
   function clickEl(el, dbl) {
+    var _orig = el;
+    el = dragTapTarget(el) || interactiveTarget(el);
+    // 与 pageOps 一致：真实点击前先有 mouseover/mousemove，
+    // 否则 hover 才展开的菜单（el-dropdown-selfdefine 等）不会打开。
+    if (_orig && _orig.scrollIntoView) _orig.scrollIntoView({ block: "center" });
+    if (_orig) { fire(_orig, "mouseover"); fire(_orig, "mouseenter"); fire(_orig, "mousemove"); }
     if (el.scrollIntoView) el.scrollIntoView({ block: "center", inline: "center" });
     if (el.focus) { try { el.focus(); } catch (e) { /* 忽略 */ } }
     fire(el, "mousedown");
     fire(el, "mouseup");
+    // 与 pageOps.clickEl 保持一致：el.click() 已派发 click，不能再补合成 click，
+    // 否则一次点击会触发两遍处理逻辑（弹窗类元素会叠出两层）。
     if (typeof el.click === "function") el.click();
     else fire(el, "click");
-    fire(el, "click");
     if (dbl) {
       fire(el, "mousedown", { detail: 2 });
       fire(el, "mouseup", { detail: 2 });
@@ -452,6 +511,27 @@ function agentDomSource() {
     }
   }
 
+  /** 文本定位常命中按钮内零尺寸 span；点击类动作应上溯到最近可交互祖先 */
+  function interactiveTarget(el) {
+    function clickable(node) {
+      if (!node || node.nodeType !== 1) return false;
+      var tag = String(node.tagName || "").toUpperCase();
+      var role = node.getAttribute && node.getAttribute("role");
+      if (tag === "BUTTON" || tag === "A" || tag === "INPUT" || tag === "SELECT" || tag === "TEXTAREA" || tag === "SUMMARY") return true;
+      if (role && /button|link|menuitem|checkbox|radio|switch|tab|option/.test(role)) return true;
+      if (node.getAttribute && (node.hasAttribute("onclick") || node.hasAttribute("ng-click"))) return true;
+      try { if (window.getComputedStyle(node).cursor === "pointer") return true; } catch (e) { /* ignore */ }
+      return false;
+    }
+    if (clickable(el)) return el;
+    var cur = el && el.parentElement;
+    while (cur) {
+      if (clickable(cur)) return cur;
+      cur = cur.parentElement;
+    }
+    return el;
+  }
+
   function setNativeValue(el, value) {
     var text = value == null ? "" : String(value);
     if (el.isContentEditable) {
@@ -580,7 +660,7 @@ function agentDomSource() {
     focus: function (ops, index) { var el = pickOrThrow(resolve(ops), index); if (el.focus) el.focus(); return "ok"; },
     evalScript: function (src) { return (0, eval)(String(src)); },
   };
-  window.__keveAgentSource = "v1";
+  window.__keveAgentSource = "v7";
   return "ok";
 })()`;
 }

package/dist/engine-cypress/cdp.js

@@ -291,7 +291,7 @@ function createCdp(send) {
         await send('Page.addScriptToEvaluateOnNewDocument', { source });
     }
     async function ensureLocator() {
-        const ok = await evaluateInAut('Boolean(window.__keveLocator && window.__keveLocatorSource === "v1")');
+        const ok = await evaluateInAut('Boolean(window.__keveLocator && window.__keveLocatorSource === "v5")');
         if (!ok) {
             const { locatorSource } = await Promise.resolve().then(() => __importStar(require('../dsl/locatorSource.js')));
             await injectLocator(locatorSource());

package/dist/engine-cypress/host.js

@@ -60,7 +60,7 @@ const diagnostics_js_1 = require("../page-agent/diagnostics.js");
 /** 单个用例体允许的最长执行时间（与 Playwright 侧 timeout 对齐） */
 const CY_TEST_TIMEOUT_MS = Number(process.env.KEVE_CY_TEST_TIMEOUT || 300_000);
 /** 单个 goal 的探索上限（与 Playwright keve-test.ts 的 GOAL_TIMEOUT_MS 对齐） */
-const CY_GOAL_TIMEOUT_MS = 300_000;
+const CY_GOAL_TIMEOUT_MS = Number(globalThis.Cypress?.env?.('KEVE_CY_GOAL_TIMEOUT') || 120_000);
 /**
  * Cypress 的运行时对象（`Cypress`）：env / config / automation / currentTest / spec。
  * 注意它**不是**命令链，不能 `.visit()` / `.wrap()`。
@@ -218,10 +218,10 @@ function installGoalExplorer(engine, bridge) {
     (0, keveGoal_js_1.setCyGoalExplorer)(async (options, ctx) => {
         const page = new agent_page_js_1.CyAgentPage(cdp);
         const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), CY_GOAL_TIMEOUT_MS);
+        let timeoutTimer;
         const host = createCyAgentHost(bridge, controller.signal);
         try {
-            const result = await (0, agent_js_1.reactLoop)(page, options.step, options.expected, {
+            const reactPromise = (0, agent_js_1.reactLoop)(page, options.step, options.expected, {
                 specFilePath: ctx.specFilePath,
                 fnSource: ctx.fnSource,
                 // fn 只是前置确定性校验：成功时也要让 Agent 重新走一遍 Re-Act 给出
@@ -236,6 +236,41 @@ function installGoalExplorer(engine, bridge) {
                 loadInitialImages: host.loadInitialImages,
                 llm: host.llm,
             });
+            // AbortSignal 只能请求协作式终止，不能保证第三方 LLM 或页面 hook
+            // 及时结束 Promise。必须同时 race 一个独立的 timer，避免最终卡在
+            // Cypress 的外层 cy.then() 超时（host.js:414）。
+            const timeoutMs = Math.max(1_000, CY_GOAL_TIMEOUT_MS);
+            const timeoutPromise = new Promise((resolve) => {
+                timeoutTimer = setTimeout(() => {
+                    controller.abort();
+                    resolve({ timedOut: true });
+                }, Math.max(1_000, timeoutMs - 1_000));
+            });
+            const outcome = await Promise.race([
+                reactPromise.then((result) => ({ timedOut: false, result })),
+                timeoutPromise,
+            ]);
+            if (!('result' in outcome)) {
+                // 让仍在收尾的 reactLoop 在后台观察 abort；当前 goal 立即返回，
+                // 后续由 keveGoal 记录 blocked，而不是继续占用 Cypress 的测试回调。
+                void reactPromise.catch(() => undefined);
+                return {
+                    expectedMet: false,
+                    conclusion: 'blocked',
+                    actions: [{
+                            action: {
+                                tool: 'done',
+                                verdict: 'blocked',
+                                text: `Agent timed out after ${timeoutMs}ms`,
+                            },
+                            toolOutput: '',
+                            result: 'ok',
+                        }],
+                    finalSnapshot: '',
+                    agentScreenshots: [],
+                };
+            }
+            const result = outcome.result;
             /**
              * Cypress 侧 reactLoop 的原生页面事件监听不会产生数据（CyAgentPage 不派发
              * console/network 事件）。真正的采集在主世界预加载脚本里完成，这里读取
@@ -265,7 +300,8 @@ function installGoalExplorer(engine, bridge) {
             };
         }
         finally {
-            clearTimeout(timer);
+            if (timeoutTimer)
+                clearTimeout(timeoutTimer);
             page.dispose();
         }
     });

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

@@ -17,6 +17,15 @@ export interface KeveGoalCallOptions {
     precondition?: string;
     step: string;
     expected: string;
+    /**
+     * 该 goal 的预期是否已被 fn 内的可执行断言完全覆盖。
+     *
+     * 由 DSL 编译器在「步骤无显式断言、但编译器补了确定性断言」时置为 true。
+     * 置位后 fn 无异常即等价于 expected 达成，无需再进 Agent Re-Act ——
+     * 否则 Agent 会按字面把「输入」理解为「把表单填完」，越界操作直到撞上
+     * 步数上限，把一步已成功的动作判成失败。
+     */
+    deterministic?: boolean;
 }
 /** agent Re-Act 的结果（P0-3 接入；未接入时由 fn 结果直接判定） */
 export interface CyGoalExploreResult {

package/dist/engine-cypress/keveGoal.js

@@ -139,6 +139,26 @@ function createCyKeveGoal(engine) {
             };
             console.log(`[keveGoal] 📊 "${options.step}" 截图差异超阈值 — 确定性失败`);
         }
+        else if (options.deterministic && fn && !fnError) {
+            // ── 确定性短路：fn 内的断言已完整覆盖 expected ──
+            // 与 fnBlocked / 截图差异同属「确定性事实」，不进 Re-Act。
+            // 进入 Re-Act 只会让 Agent 重读一句宽泛的步骤文案，把动作做到本步之外。
+            reactResult = {
+                expectedMet: true,
+                conclusion: 'pass',
+                actions: [{
+                        action: {
+                            tool: 'done',
+                            verdict: 'pass',
+                            text: `Deterministic step: fn 断言已通过（${options.expected}）`,
+                        },
+                        toolOutput: '',
+                        result: 'ok',
+                    }],
+                agentScreenshots: [],
+            };
+            console.log(`[keveGoal] ⚡ "${options.step}" 确定性步骤 — fn 断言通过，跳过 Agent Re-Act`);
+        }
         else {
             // fn 成功 / 失败都交给评测器。fn 只是前置动作与确定性校验：
             //  - fn 成功 ≠ expected 达成（fn 可能只覆盖预期的一个子集）；

package/dist/engine-cypress/pageOps.js

@@ -21,7 +21,7 @@ exports.diagnosticsSource = diagnosticsSource;
 function pageOpsSource() {
     return `(() => {
   "use strict";
-  if (window.__keveOpsSource === "v1") return "cached";
+  if (window.__keveOpsSource === "v7") return "cached";
 
   function locator() {
     if (!window.__keveLocator) throw new Error("[keve] locator 未注入");
@@ -64,14 +64,82 @@ function pageOpsSource() {
     el.dispatchEvent(new MouseEvent(type, init));
   }
 
+  /** 文本定位常命中按钮内零尺寸 span；点击类动作应上溯到最近可交互祖先 */
+  function interactiveTarget(el) {
+    function clickable(node) {
+      if (!node || node.nodeType !== 1) return false;
+      var tag = String(node.tagName || "").toUpperCase();
+      var role = node.getAttribute && node.getAttribute("role");
+      if (tag === "BUTTON" || tag === "A" || tag === "INPUT" || tag === "SELECT" || tag === "TEXTAREA" || tag === "SUMMARY") return true;
+      if (role && /button|link|menuitem|checkbox|radio|switch|tab|option/.test(role)) return true;
+      if (node.getAttribute && (node.hasAttribute("onclick") || node.hasAttribute("ng-click"))) return true;
+      try { if (window.getComputedStyle(node).cursor === "pointer") return true; } catch (e) { /* ignore */ }
+      return false;
+    }
+    if (clickable(el)) return el;
+    var cur = el && el.parentElement;
+    while (cur) {
+      if (clickable(cur)) return cur;
+      cur = cur.parentElement;
+    }
+    return el;
+  }
+
+  /**
+   * KwaiBI 图表工具栏把 mousedown/mouseup 绑定在 grid-free-item.c-toolbar-item
+   * 上（v-drag-no-tap 指令），且要求 down/up 落在同一个元素。data-e2e-name
+   * 常挂在外层 SPAN 或 c-toolbar-item-container 上，只点上溯祖先不会触发。
+   */
+  function dragTapTarget(el) {
+    if (!el) return null;
+    var cur = el.nodeType === 1 ? el : (el.parentElement || null);
+    while (cur) {
+      var cls = String(cur.getAttribute && cur.getAttribute("class") || "");
+      if (cls.indexOf("c-toolbar-item") >= 0) return cur;
+      cur = cur.parentElement;
+    }
+    if (el.nodeType === 1 && el.querySelector) {
+      var found = el.querySelector(".c-toolbar-item");
+      if (found) return found;
+    }
+    return null;
+  }
+
+  /** 悬停事件序列：部分下拉/弹层（el-dropdown-selfdefine / el-popover__reference）由 hover 打开 */
+  function hoverEl(el) {
+    if (!el) return;
+    el.scrollIntoView({ block: "center" });
+    mouse(el, "mouseover");
+    mouse(el, "mouseenter");
+    mouse(el, "mousemove");
+  }
+
   function clickEl(el, dbl) {
+    var _orig = el;
+    // 若命中 drag-no-tap 工具栏项或其容器，事件必须落在该子项上；
+    // 普通元素仍按可交互祖先处理。
+    el = dragTapTarget(el) || interactiveTarget(el);
+    // 点击前补真实鼠标移动序列：浏览器点击本身会先产生 mouseover/mousemove，
+    // 缺了它会让依赖 hover 展开的下拉菜单按钮（如 KwaiBI 表格菜单）不生效。
+    hoverEl(_orig);
+    try {
+      window.__keveLastClick = {
+        origTag: _orig && _orig.tagName,
+        origCls: _orig && (_orig.getAttribute && _orig.getAttribute("class") || ""),
+        tag: el && el.tagName,
+        cls: el && (el.getAttribute && el.getAttribute("class") || ""),
+        at: Date.now(),
+      };
+    } catch (e) { /* debug */ }
     el.scrollIntoView({ block: "center", inline: "center" });
     el.focus && el.focus();
     mouse(el, "mousedown");
     mouse(el, "mouseup");
+    // 单次点击只能派发一个 click：el.click() 自身即会派发 click，
+    // 再补一个合成 click 会让「打开弹窗」这类幂等性差的处理逻辑执行两次
+    // （实测一次「新建看板」会叠出两层 el-dialog，后续取 els[0] 命中被遮住的底层）。
     if (typeof el.click === "function") el.click();
     else mouse(el, "click");
-    mouse(el, "click");
     if (dbl) {
       mouse(el, "mousedown", 2);
       mouse(el, "mouseup", 2);
@@ -104,6 +172,13 @@ function pageOpsSource() {
     return t.replace(/\\s+/g, " ").trim();
   }
 
+  // 表单元素当前值：只读 value，不回退 textContent。
+  // 输入类断言必须用它 —— input 的 textContent 恒为空，textOf 取不到用户输入。
+  function valueOf(el) {
+    if (!el) return "";
+    return el.value != null ? String(el.value) : "";
+  }
+
   function attrOf(el, name) {
     if (!el) return null;
     return el.getAttribute(name);
@@ -133,6 +208,7 @@ function pageOpsSource() {
     },
     text: function (refs) { return textOf(first(refs)); },
     texts: function (refs) { return resolve(refs).map(textOf); },
+    value: function (refs) { return valueOf(first(refs)); },
     visible: function (refs) { return isVisible(first(refs)); },
     hidden: function (refs) { var els = resolve(refs); return !els.length || !isVisible(els[0]); },
     exists: function (refs) { return resolve(refs).length > 0; },
@@ -157,7 +233,7 @@ function pageOpsSource() {
       return (0, eval)("(" + expr + ")");
     },
   };
-  window.__keveOpsSource = "v1";
+  window.__keveOpsSource = "v7";
   return "ok";
 })()`;
 }

package/dist/engine-playwright/engineAdapter.d.ts

@@ -52,6 +52,13 @@ export declare class PlaywrightEngine implements EngineAdapter {
     expectNotText(expected: string, ...refs: (ElementRef | ElementEntry)[]): Promise<void>;
     expectTextEquals(expected: string, ...refs: (ElementRef | ElementEntry)[]): Promise<void>;
     expectTextNotEquals(expected: string, ...refs: (ElementRef | ElementEntry)[]): Promise<void>;
+    /**
+     * 表单元素当前值断言（input/textarea/select 的 value）。
+     *
+     * 必须用 toHaveValue 而不是 toHaveText：input 的 textContent 恒为空，
+     * 文本断言对用户输入永远失败，会把它误判成用例缺陷。
+     */
+    expectValue(expected: string, ...refs: (ElementRef | ElementEntry)[]): Promise<void>;
     expectCount(count: number, ...refs: (ElementRef | ElementEntry)[]): Promise<void>;
     expectNonEmptyCount(count: number, ...refs: (ElementRef | ElementEntry)[]): Promise<void>;
     expectExists(...refs: (ElementRef | ElementEntry)[]): Promise<void>;

package/dist/engine-playwright/engineAdapter.js

@@ -264,6 +264,16 @@ class PlaywrightEngine {
         const locator = this.resolve(refs);
         await (0, test_1.expect)(locator.first()).not.toHaveText(expected);
     }
+    /**
+     * 表单元素当前值断言（input/textarea/select 的 value）。
+     *
+     * 必须用 toHaveValue 而不是 toHaveText：input 的 textContent 恒为空，
+     * 文本断言对用户输入永远失败，会把它误判成用例缺陷。
+     */
+    async expectValue(expected, ...refs) {
+        const locator = this.resolve(refs);
+        await (0, test_1.expect)(locator.first()).toHaveValue(expected);
+    }
     async expectCount(count, ...refs) {
         const locator = this.resolve(refs);
         await (0, test_1.expect)(locator).toHaveCount(count);

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

@@ -32,6 +32,14 @@ export interface KeveGoalCallOptions {
     precondition?: string;
     step: string;
     expected: string;
+    /**
+     * 该 goal 的预期是否已被 fn 内的可执行断言完全覆盖。
+     *
+     * 由 DSL 编译器在「步骤无显式断言、但编译器补了确定性断言」时置为 true。
+     * 与 Cypress 侧同构：置位后 fn 无异常即等价于 expected 达成，跳过 Agent Re-Act，
+     * 避免 Agent 按字面把「输入」扩大成「把表单填完」而越界操作。
+     */
+    deterministic?: boolean;
 }
 type KeveFixture = {
     keveGoal: (options: KeveGoalCallOptions, fn?: () => Promise<void>) => Promise<void>;

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

@@ -299,6 +299,27 @@ exports.test = test_1.test.extend({
                         conclusion: 'fail',
                     };
                 }
+                else if (options.deterministic && fn && !fnError) {
+                    // ── 确定性短路：fn 内的断言已完整覆盖 expected ──
+                    // 与 Cypress 侧同构。Agent Re-Act 在这个场景没有可提供的信息，
+                    // 只会重读宽泛步骤文案并把动作做到本步之外。
+                    console.log(`[keveGoal] ⚡ "${options.step}" deterministic step — fn 断言通过，跳过 Agent Re-Act`);
+                    reactResult = {
+                        expectedMet: true,
+                        actions: [{
+                                action: {
+                                    tool: 'done',
+                                    verdict: 'pass',
+                                    text: `Deterministic step: fn 断言已通过（${options.expected}）`,
+                                },
+                                toolOutput: '',
+                                result: 'ok',
+                            }],
+                        finalSnapshot: '',
+                        agentScreenshots: [],
+                        conclusion: '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.22",
+  "version": "0.0.23",
   "description": "AI-powered full-stack test agent CLI - static analysis, unit test, component test, E2E test, execute, evaluate, and report",
   "license": "MIT",
   "bin": {
@@ -95,4 +95,4 @@
     "tsx": "^4.19.0",
     "typescript": "^6.0.2"
   }
-}
+}

package/scripts/run-probe.mjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as url from 'node:url';
+import { spawnSync } from 'node:child_process';
+import { resolveEngineBin, buildExecEnv } from '../dist/runner/index.js';
+
+const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+const suiteRoot = path.resolve(__dirname, '..');
+const runtimeDir = path.join(__dirname, 'runtime');
+const defaultBackendRoot = path.resolve(suiteRoot, '..', '..', '..', 'eve-backend');
+
+const inputFile = process.argv[2];
+const specGlob = process.argv[3] || 'specs/__probe.spec.ts';
+const round = process.argv[4] || 'probe';
+const input = JSON.parse(fs.readFileSync(inputFile, 'utf-8'));
+const taskDir = input.taskDir;
+const backendRoot = input.backendRoot || defaultBackendRoot;
+const resultDir = path.join(taskDir, 'reports', `round-${round}`);
+fs.mkdirSync(resultDir, { recursive: true });
+
+const env = buildExecEnv({
+  input, taskDir, round, engine: 'cypress', defaultBackendRoot, suiteRoot,
+});
+const cypressBin = resolveEngineBin({ engine: 'cypress', backendRoot, suiteRoot });
+const configPath = path.join(runtimeDir, 'cypress.config.mjs');
+const res = spawnSync(cypressBin, [
+  'run', '--project', taskDir, '--config-file', configPath,
+  '--browser', 'electron', '--spec', specGlob,
+], {
+  cwd: taskDir,
+  stdio: 'inherit',
+  env: { ...env, ELECTRON_RUN_AS_NODE: '' },
+});
+process.exit(res.status ?? 1);