@kkeve/suite 0.0.11 → 0.0.13

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

@@ -165,11 +165,13 @@ export interface CaseReportItem {
     stdout: string;
     /** Playwright 步骤 */
     pwSteps: any[];
-    /** AI评估结论: "通过" | "不通过" | "待确认" */
+    /** AI评估结论: "通过" | "不通过" | "阻塞" | "跳过" */
     data: string;
     /** AI评估置信度 0-100 */
     confidence: number;
-    /** AI评估推理过程 */
+    /** AI评估 thought（原始推理/原因文本，用于根因展示） */
+    thought: string;
+    /** AI评估推理过程（同 thought，保持向后兼容） */
     confidenceReason: string;
     /** 步骤截图路径列表（前端按需加载，不再内嵌 base64） */
     stepScreenshots: {

package/dist/core/generateReport/reportData.js

@@ -437,7 +437,7 @@ async function generateReportData(opts) {
     // Derive taskDir from resultsPath: .../test-artifacts/round-N/test-results.json → taskDir is 2 levels up from test-artifacts/
     const taskDir = path.resolve(path.dirname(TEST_RESULTS_JSON), '..', '..');
     const caseResultMap = buildCaseResultMap(specs, taskDir);
-    let total = 0, passed = 0, failed = 0, skipped = 0;
+    let total = 0;
     const caseResults = [];
     const confidenceDist = { '95-100': 0, '61-90': 0, '41-60': 0, '0-40': 0 };
     // Read confidence-data.jsonl (AI evaluation results from KeveReporter)
@@ -516,12 +516,6 @@ async function generateReportData(opts) {
         total++;
         // Playwright returns "timedOut" for test timeout — treat as failed
         const effectiveStatus = result.status === 'timedOut' ? 'failed' : result.status;
-        if (effectiveStatus === 'passed')
-            passed++;
-        else if (effectiveStatus === 'skipped')
-            skipped++;
-        else
-            failed++;
         // AI evaluation: match by Playwright title (scene.title, the canonical key)
         const aiEntry = aiConfidenceMap[result.title] || aiConfidenceMap[caseId];
         const data = effectiveStatus === 'skipped' ? '待确认' : (aiEntry?.data || '待确认');
@@ -652,6 +646,7 @@ async function generateReportData(opts) {
             stdout: result.stdout,
             data,
             confidence,
+            thought: aiEntry?.thought || (effectiveStatus === 'skipped' ? '用例被跳过（非自动执行）' : ''),
             confidenceReason,
             stepScreenshots: stepScreenshotsPaths,
             screenshotPath: result.screenshotPath,
@@ -668,7 +663,6 @@ async function generateReportData(opts) {
             if (caseResultMap[caseDef.id])
                 continue; // Already included above
             total++;
-            failed++;
             // Missing cases: test was not executed by Playwright, so AI evaluation is skipped
             const data = '跳过';
             const confidence = 0;
@@ -692,6 +686,7 @@ async function generateReportData(opts) {
                 stdout: '',
                 data,
                 confidence,
+                thought: 'YAML中定义但Playwright未执行',
                 confidenceReason: 'YAML中定义但Playwright未执行，无AI评估数据',
                 stepScreenshots: [],
                 screenshotPath: '',
@@ -702,15 +697,16 @@ async function generateReportData(opts) {
             });
         }
     }
-    const passRate = total > 0 ? ((passed / total) * 100).toFixed(1) : '0';
     const summaryJson = {
-        status: failed > 0 ? 'partial' : 'success',
+        status: 'partial',
         mr_id: testCasesData.mr_id, description: testCasesData.description,
         docs_url: testCasesData.docs_url,
         generated_at: new Date().toISOString().split('T')[0],
         round: currentRound,
         phases: { phase1: 'completed', phase2: 'completed', phase3: 'completed', phase4: 'completed' },
-        summary: { total, passed, failed, skipped, pending: 0, passRate: `${passRate}%` },
+        // passed/failed/skipped/passRate 已移至前端 computedSummary 实时计算
+        // 保留 total 供兜底展示
+        summary: { total, round: currentRound },
         confidenceDist: {
             '95-100%可信': confidenceDist['95-100'],
             '61-90%需分析': confidenceDist['61-90'],

package/dist/core/keve-registry.d.ts

@@ -12,7 +12,7 @@ export interface KeveGoalMeta {
     order: number;
 }
 /** 错误分类类型 */
-export type ErrorCategory = 'script' | 'env' | 'assert' | 'visual' | 'text-mismatch' | 'react-fail' | 'pass' | 'unknown';
+export type ErrorCategory = 'script' | 'env' | 'assert' | 'visual' | 'text-mismatch' | 'incomplete' | 'pass' | 'unknown';
 /** 场景执行后的评估元数据，由 @keveScene 装饰器写入，Reporter 读取 */
 export interface KeveEvalMeta {
     /** 错误分类 */

package/dist/core/keve-report.js

@@ -76,7 +76,7 @@ class KeveReporter {
         visual: 80, // 视觉断言已评估，置信度较高
         'text-mismatch': 70, // UI文案格式不匹配（功能逻辑正确，文案措辞变了）
         assert: 50, // Playwright 断言失败，需人工确认
-        'react-fail': 40, // AI 探索未达预期，需人工确认
+        incomplete: 0, // 执行被中断（超时/action 耗尽），无法得出结论
         env: 0, // 环境问题，测试结果不可信
         unknown: 0, // 未知异常，无参考价值
     };
@@ -89,8 +89,18 @@ class KeveReporter {
         let skipAI = false;
         let classifiedMessage = '';
         if (result.status === 'skipped') {
-            skipAI = true;
-            effectiveCategory = 'unknown';
+            // 主动跳过（testInfo.skip，如"非自动执行"）— 独立处理，data='跳过'
+            this.appendRecord({
+                title: test.title,
+                data: '跳过',
+                confidence: 0,
+                thought: '用例被跳过（非自动执行）',
+                errorCategory: 'unknown',
+                steps,
+                diagnosticHint: undefined,
+            });
+            console.log(`[keve-reporter] ${test.title}: SKIPPED`);
+            return;
         }
         else if (result.status === 'passed') {
             effectiveCategory = 'pass';
@@ -107,6 +117,11 @@ class KeveReporter {
                 effectiveCategory = 'env';
                 skipAI = true;
             }
+            else if (agentConclusion.result === 'incomplete') {
+                // Agent 执行被中断（超时/action 耗尽），无法得出结论
+                effectiveCategory = 'incomplete';
+                skipAI = true;
+            }
             else {
                 // Agent said fail → assert/text-mismatch depending on diagnostic hints
                 const hint = buildDiagnosticHint(result.attachments);
@@ -145,10 +160,10 @@ class KeveReporter {
                 effectiveCategory = 'env';
                 skipAI = true;
             }
-            // 5. Re-Act loop 失败：AI 探索未达到预期（关键分类）
+            // 5. Re-Act loop 失败：执行被中断（action 耗尽 / 未达预期）→ incomplete
             else if (rawError.includes('Re-Act loop did not achieve') || rawError.includes('Expected not achieved after agent explore')) {
-                effectiveCategory = 'react-fail';
-                skipAI = false;
+                effectiveCategory = 'incomplete';
+                skipAI = true;
             }
             // 5.5 文案不匹配
             else if (rawError.includes('Expected not achieved')) {
@@ -158,8 +173,8 @@ class KeveReporter {
                     skipAI = false;
                 }
                 else {
-                    effectiveCategory = 'react-fail';
-                    skipAI = false;
+                    effectiveCategory = 'incomplete';
+                    skipAI = true;
                 }
             }
             // 6. 兜底
@@ -180,9 +195,13 @@ class KeveReporter {
                             ? `无法分类的异常(${classifiedMessage})，跳过AI评估`
                             : effectiveCategory === 'pass'
                                 ? `Agent判定通过但fn脚本执行失败(${classifiedMessage})，脚本需修复`
-                                : '用例被跳过';
-            // AI评估列显示"跳过"（表示AI未参与评估），而非"不通过"
-            const aiData = (effectiveCategory !== 'assert' && effectiveCategory !== 'react-fail' && effectiveCategory !== 'text-mismatch') ? '跳过' : '不通过';
+                                : effectiveCategory === 'incomplete'
+                                    ? `执行被中断(${classifiedMessage})，Agent未完成目标，建议重跑`
+                                    : `无法分类的异常(${classifiedMessage})`;
+            // AI评估列输出：
+            // - assert/text-mismatch → "不通过"（有明确失败结论，skipAI=false）
+            // - 其余所有无法得出结论的 → "阻塞"（包括 incomplete/env/script/visual/pass/unknown）
+            const aiData = (effectiveCategory === 'assert' || effectiveCategory === 'text-mismatch') ? '不通过' : '阻塞';
             const keveScreenshots = (0, reportData_1.parseKeveAsserts)(result.attachments).map(ka => ka.label);
             this.appendRecord({
                 title: test.title,
@@ -307,26 +326,26 @@ function parseSteps(attachments) {
 }
 /** Extract Agent conclusion (result + text) from keveGoalResult steps */
 function extractAgentConclusion(steps) {
-    // Walk steps in reverse to find the most recent conclusion
-    for (let i = steps.length - 1; i >= 0; i--) {
-        const step = steps[i];
-        // Step-level conclusion (from agent.ts buildResult → keveGoalResult attachment)
-        if (step.conclusion) {
-            // Find the done action text for context
-            const doneAction = step.actions?.find(a => a.tool === 'done');
-            return { result: step.conclusion, text: doneAction?.text || '' };
-        }
-        // Action-level conclusion (from done action's 'result' field)
-        if (step.actions) {
-            for (let j = step.actions.length - 1; j >= 0; j--) {
-                const action = step.actions[j];
-                if (action?.tool === 'done' && action?.conclusion) {
-                    return { result: action.conclusion, text: action.text || '' };
-                }
+    if (steps.length === 0)
+        return undefined;
+    // keveGoal 串行执行：取最后一步的结论作为用例整体结论
+    const lastStep = steps[steps.length - 1];
+    // 最后一步有明确结论（Agent 调用了 done）→ 直接使用
+    if (lastStep.conclusion) {
+        const doneAction = lastStep.actions?.find(a => a.tool === 'done');
+        return { result: lastStep.conclusion, text: doneAction?.text || '' };
+    }
+    // Action 级别结论兜底（来自 done action 的 result 字段）
+    if (lastStep.actions) {
+        for (let j = lastStep.actions.length - 1; j >= 0; j--) {
+            const action = lastStep.actions[j];
+            if (action?.tool === 'done' && action?.conclusion) {
+                return { result: action.conclusion, text: action.text || '' };
             }
         }
     }
-    return undefined;
+    // 最后一步无任何结论 → 执行被中断（超时 / action 耗尽）
+    return { result: 'incomplete', text: '执行被中断，Agent未完成目标' };
 }
 /** Build diagnosticHint from keveGoalResult attachments (primary) + fallback to keveDiagnosticHint */
 function buildDiagnosticHint(attachments) {

package/dist/core/keve-test.d.ts

@@ -39,5 +39,7 @@ type KeveFixture = {
         noImages?: boolean;
         outputPath?: string;
     }) => Promise<any>;
+    /** 将内置 testInfo 包装为可解构 fixture，允许脚本直接写 { page, keveGoal, testInfo } */
+    testInfo: import('@playwright/test').TestInfo;
 };
 export declare const test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & KeveFixture, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;

package/dist/core/keve-test.js

@@ -87,14 +87,20 @@ keve_aspect_1.keveAspect.register({
     phase: 'after',
     order: 20,
     async execute(ctx, result) {
-        if (!result?.actions?.length || !result.success)
+        if (!result?.actions?.length)
             return;
-        learned_actions_1.learnedActions.add(ctx.step, result.actions);
+        const url = ctx.page.url();
+        learned_actions_1.learnedActions.add(ctx.step, result.actions, url, result.success);
     },
 });
 // ─── (diagnostic extraction moved to page-agent/diagnostic.ts, called via onAfterTask hook) ──
 // ─── Fixture ────────────────────────────────────────────────────────
 exports.test = test_1.test.extend({
+    // ── 将内置 testInfo 包装为可解构 fixture ─────────────────────────
+    // 测试方法可直接写 { page, keveGoal, testInfo }，不再报 "unknown parameter" 错误
+    testInfo: async ({}, use, testInfo) => {
+        await use(testInfo);
+    },
     browser: async ({}, use, testInfo) => {
         if ((0, global_setup_1.isCdpMode)()) {
             const browser = await (0, global_setup_1.getCdpBrowser)(); // 复用全局共享的 CDP browser
@@ -170,6 +176,7 @@ exports.test = test_1.test.extend({
             let result;
             const fnSource = fn?.toString() || undefined;
             let fnError;
+            let fnBlocked = false; // true when fn error is environment-blocked (skip agent Re-Act)
             if (fn) {
                 try {
                     await fn();
@@ -178,6 +185,13 @@ exports.test = test_1.test.extend({
                 catch (err) {
                     fnError = err?.message || String(err);
                     console.log(`[keveGoal] "${options.step}" fn error: ${fnError}`);
+                    // ── Detect environment-blocked errors: skip Agent Re-Act, directly BLOCKED ──
+                    // When fn fails due to empty URL, connection refused, timeout, or navigation to invalid URL,
+                    // Agent exploration cannot fix environment issues — waste of time and tokens.
+                    fnBlocked = isEnvironmentBlockedError(err);
+                    if (fnBlocked) {
+                        console.log(`[keveGoal] 🚫 "${options.step}" BLOCKED — environment error detected, skipping agent Re-Act`);
+                    }
                 }
             }
             // ── Capture fn-after screenshot (fn 执行后的页面状态，传给 agent 说明执行前后) ──
@@ -188,46 +202,77 @@ exports.test = test_1.test.extend({
                 }
                 catch { /* non-critical */ }
             }
-            // ── Hand off to agent: agent does Re-Act ──
-            const learnedHint = learned_actions_1.learnedActions.getHint(options.step);
+            // ── Hand off to agent: agent does Re-Act (OR shortcut to blocked if fnBlocked) ──
+            const currentUrl = page.url();
+            const learnedHint = learned_actions_1.learnedActions.getHint(options.step, currentUrl);
             let reactResult;
             let reactTimedOut = false;
-            // ── Per-goal timeout: prevent one slow goal from exhausting the test timeout ──
-            // Default 300s per goal; total test timeout should be ≥ (goals × 300s + overhead)
-            const GOAL_TIMEOUT_MS = 300_000;
-            const goalTimeoutController = new AbortController();
-            const goalTimeout = setTimeout(() => {
-                goalTimeoutController.abort();
-                console.log(`[keveGoal] ⏰ "${options.step}" timed out after ${GOAL_TIMEOUT_MS}ms — stopping agent`);
-            }, GOAL_TIMEOUT_MS);
-            try {
-                reactResult = await (0, agent_1.reactLoop)(page, options.step, options.expected, {
-                    learnedActionsHint: learnedHint,
-                    specFilePath: ctx.specFilePath,
-                    fnSource,
-                    fnResult: fnError ? { error: fnError } : { success: true },
-                    signal: goalTimeoutController.signal,
-                    goalScreenshotBefore: goalScreenshotBefore || undefined,
-                    fnAfterScreenshot: fnAfterScreenshot || undefined,
-                });
-            }
-            catch (reactErr) {
-                reactTimedOut = true;
-                const isGoalTimeout = goalTimeoutController.signal.aborted;
-                const msg = isGoalTimeout
-                    ? `Goal timed out (${GOAL_TIMEOUT_MS}ms)`
-                    : (reactErr?.message || String(reactErr));
-                console.log(`[keveGoal] reactLoop interrupted: ${msg.slice(0, 200)}`);
+            if (fnBlocked) {
+                // ── Shortcut: environment error detected in fn, skip Agent Re-Act entirely ──
+                // Agent exploration cannot fix empty URLs, connection refused, or navigation failures.
+                // Directly produce a blocked result with the fn error as explanation.
                 reactResult = {
                     expectedMet: false,
-                    actions: [],
+                    actions: [{
+                            action: { tool: 'done', verdict: 'blocked', text: `Environment blocked: ${fnError}` },
+                            toolOutput: '',
+                            result: 'ok',
+                        }],
                     finalSnapshot: '',
                     agentScreenshots: [],
-                    conclusion: isGoalTimeout ? 'blocked' : 'fail',
+                    conclusion: 'blocked',
                 };
             }
-            finally {
-                clearTimeout(goalTimeout);
+            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)
+                const GOAL_TIMEOUT_MS = 300_000;
+                const goalTimeoutController = new AbortController();
+                const goalTimeout = setTimeout(() => {
+                    goalTimeoutController.abort();
+                    console.log(`[keveGoal] ⏰ "${options.step}" timed out after ${GOAL_TIMEOUT_MS}ms — stopping agent`);
+                }, GOAL_TIMEOUT_MS);
+                try {
+                    reactResult = await (0, agent_1.reactLoop)(page, options.step, options.expected, {
+                        learnedActionsHint: learnedHint,
+                        specFilePath: ctx.specFilePath,
+                        fnSource,
+                        fnResult: fnError ? { error: fnError } : { success: true },
+                        signal: goalTimeoutController.signal,
+                        goalScreenshotBefore: goalScreenshotBefore || undefined,
+                        fnAfterScreenshot: fnAfterScreenshot || undefined,
+                    });
+                }
+                catch (reactErr) {
+                    reactTimedOut = true;
+                    const isGoalTimeout = goalTimeoutController.signal.aborted;
+                    const msg = isGoalTimeout
+                        ? `Goal timed out (${GOAL_TIMEOUT_MS}ms)`
+                        : (reactErr?.message || String(reactErr));
+                    console.log(`[keveGoal] reactLoop interrupted: ${msg.slice(0, 200)}`);
+                    reactResult = {
+                        expectedMet: false,
+                        actions: [],
+                        finalSnapshot: '',
+                        agentScreenshots: [],
+                        conclusion: isGoalTimeout ? 'blocked' : 'fail',
+                    };
+                }
+                finally {
+                    clearTimeout(goalTimeout);
+                }
+            } // end of else (non-blocked path)
+            // ── Deterministic override: fn assertion failure cannot be overridden by Agent "pass" ──
+            // When fn has a hard assertion failure (Expected X, Received Y), the value mismatch
+            // is a fact, not a judgment. The Agent may rationalize "consistency" (e.g. "both pages
+            // show 15px, so consistent") and override to pass, but 15px ≠ 16px is a definitive failure.
+            // This is the per-goal equivalent of pipeline afterHook (case-gen-validate) —
+            // deterministic check > LLM judgment.
+            if (fnError && !fnBlocked && reactResult.expectedMet && isAssertionFailure(fnError)) {
+                console.log(`[keveGoal] ⚠️ "${options.step}" Agent said PASS but fn had assertion failure — overriding to FAIL`);
+                console.log(`[keveGoal]    fn assertion: ${fnError}`);
+                reactResult.expectedMet = false;
+                reactResult.conclusion = 'fail';
             }
             result = {
                 success: reactResult.expectedMet,
@@ -236,8 +281,10 @@ exports.test = test_1.test.extend({
                 error: reactResult.expectedMet
                     ? undefined
                     : reactResult.conclusion === 'blocked'
-                        ? new Error(`Blocked: ${reactTimedOut ? `Agent 超时 (${GOAL_TIMEOUT_MS}ms)` : (reactResult.actions?.filter((a) => a.action?.tool === 'done').pop()?.action?.text || 'Agent blocked')}`)
-                        : new Error(`Expected not achieved: ${options.expected}`),
+                        ? new Error(`Blocked: ${fnBlocked ? fnError : (reactTimedOut ? `Agent 超时 (300000ms)` : (reactResult.actions?.filter((a) => a.action?.tool === 'done').pop()?.action?.text || 'Agent blocked'))}`)
+                        : (fnError && isAssertionFailure(fnError) && !fnBlocked)
+                            ? new Error(`Assertion failed: ${fnError}`)
+                            : new Error(`Expected not achieved: ${options.expected}`),
             };
             // Attach Agent conclusion for downstream consumers
             if (reactResult.conclusion)
@@ -363,6 +410,109 @@ exports.test = test_1.test.extend({
 const keve_decorators_2 = require("./keve-decorators");
 (0, keve_decorators_2.setKeveTest)(exports.test);
 // ── 辅助函数 ──
+/**
+ * Detect environment-blocked errors from fn execution.
+ *
+ * When fn (deterministic script) fails with these patterns, Agent Re-Act cannot
+ * fix the issue — the error is environmental, not application-level:
+ *
+ * 1. Empty/undefined URL → page.goto(''), page.goto(undefined)
+ * 2. Connection refused / net::ERR_CONNECTION_REFUSED
+ * 3. Navigation timeout (page not reachable)
+ * 4. Invalid URL format
+ * 5. SSO redirect / auth failure (not the app's fault)
+ *
+ * Returns true → keveGoal skips Agent Re-Act and directly reports BLOCKED
+ * with the fn error as the blocking reason.
+ */
+function isEnvironmentBlockedError(err) {
+    const msg = (err?.message || String(err)).toLowerCase();
+    // Empty/undefined URL: page.goto('') or page.goto(undefined)
+    if (msg.includes('url must not be empty') || msg.includes('url is empty')
+        || msg.includes('invalid url') || msg.includes('url is undefined')
+        || msg.includes('navigation to ""') || msg.includes("navigation to ''")) {
+        return true;
+    }
+    // page.goto(undefined): Playwright type error "url: expected string, got undefined"
+    // This happens when process.env.PAGE_* is not set — environment config issue, not app issue
+    if ((msg.includes('expected string') || msg.includes('expected a string'))
+        && (msg.includes('got undefined') || msg.includes('got null') || msg.includes('received undefined'))) {
+        return true;
+    }
+    // Connection refused / network unreachable
+    if (msg.includes('err_connection_refused') || msg.includes('connection refused')
+        || msg.includes('net::err_connection') || msg.includes('err_name_not_resolved')
+        || msg.includes('err_address_unreachable') || msg.includes('err_internet_disconnected')
+        || msg.includes('err_connection_timed_out') || msg.includes('err_connection_reset')) {
+        return true;
+    }
+    // Navigation timeout (page not reachable in time)
+    if (msg.includes('navigation timeout of') || msg.includes('timeout of') && msg.includes('exceeded')
+        || msg.includes('page.goto: timeout') || msg.includes('navigating to') && msg.includes('timed out')) {
+        return true;
+    }
+    // Playwright locator/waitForSelector timeout — selector not found on page (fn script issue, not app crash)
+    // e.g. "Timeout 15000ms exceeded while waiting for locator('.selector') to be visible"
+    // This is a script-quality issue (wrong selector), not an env blocked error.
+    // Return false here — let Agent take over rather than treating as BLOCKED.
+    // Note: we intentionally do NOT return true; these should fall through to Agent Re-Act.
+    // IDC network segment restriction
+    if (msg.includes('unable to access on the idc network segment')
+        || msg.includes('idc network segment') || msg.includes('40314')) {
+        return true;
+    }
+    // SSO / auth redirect (not the app's fault)
+    if (msg.includes('sso redirect') || msg.includes('login redirect detected')
+        || msg.includes('err_too_many_redirects')) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Detect assertion failures from fn execution (Expected/Received patterns).
+ *
+ * When fn (deterministic script) throws a hard assertion failure with concrete
+ * Expected vs Received values, the mismatch is a *fact*, not a judgment.
+ * The Agent may rationalize "consistency" (e.g. "both pages show 15px → consistent → pass")
+ * and override to pass, but 15px ≠ 16px is a definitive failure.
+ *
+ * This function identifies such assertion failures so keveGoal can:
+ *   - Override Agent "pass" → "fail" when the fn proved a value mismatch
+ *   - Use the precise assertion message in the error (instead of generic "expected not achieved")
+ *
+ * Returns true for assertion errors, false for environment/runtime errors.
+ */
+function isAssertionFailure(error) {
+    const msg = (error || '').toLowerCase();
+    // Exclude Playwright API type errors (parameter type mismatch, not value assertion)
+    // e.g. "page.goto: url: expected string, got undefined" — this is an env config error,
+    // not a functional assertion failure. isEnvironmentBlockedError() handles it instead.
+    if (msg.includes('expected string') || msg.includes('expected a string')
+        || msg.includes('expected number') || msg.includes('expected boolean')) {
+        // Only exclude if it looks like an API parameter error (not an assertion)
+        if (msg.includes('got undefined') || msg.includes('got null')
+            || msg.includes('received undefined') || msg.includes('received null')) {
+            return false;
+        }
+    }
+    // Jest/Vitest/playwright assertion: "Expected: X, Received: Y"
+    if (msg.includes('expected') && msg.includes('received'))
+        return true;
+    // AssertionError / assert keyword
+    if (msg.includes('assertionerror') || msg.includes('assertion failed')
+        || msg.includes('assertion error'))
+        return true;
+    // expect(x).toBe(y) / expect(x).toEqual(y) pattern
+    // Note: must NOT match Playwright timeout messages like "Timeout 15000ms exceeded waiting for locator(...) to be visible"
+    // Those are env/timeout errors, not value assertion failures.
+    if ((msg.includes(' to be ') && !msg.includes('timeout') && !msg.includes('waiting for') && !msg.includes('exceeded'))
+        || msg.includes(' to equal ') || msg.includes(' to deeply equal '))
+        return true;
+    // Playwright expect: "expected string, received number" etc.
+    if (msg.includes('expected ') && (msg.includes(' but ') || msg.includes(' got ') || msg.includes(' received ')))
+        return true;
+    return false;
+}
 /**
  * 截图并保存到 test-artifacts，返回相对 taskDir 的路径
  * @param phase 'before' | 'after-fn' — 用于文件名前缀

package/dist/core/learned-actions.d.ts

@@ -4,21 +4,50 @@
  * When one keveGoal's Re-Act loop discovers a working action sequence,
  * other goals in the same round can use those discoveries as hints.
  *
- * Key format: "${step}" — the step description
- * Value: ActionLogEntry[] — the successful action sequence
+ * v2: Fuzzy matching by token Jaccard similarity + page URL pattern.
+ *     Exact match is tried first; if no hit, fuzzy search across all entries.
  */
+interface CacheEntry {
+    step: string;
+    actions: any[];
+    url?: string;
+    success: boolean;
+}
 export declare class LearnedActions {
     private cache;
-    /** Store discovered actions for a step */
-    add(step: string, actions: any[]): void;
-    /** Retrieve discovered actions for a step */
+    /** Store discovered actions for a step (with optional page URL for context matching)
+     *  @param success Whether the step succeeded — failed entries are stored with warnings only
+     */
+    add(step: string, actions: any[], url?: string, success?: boolean): void;
+    /** Retrieve discovered actions for a step (exact match) */
     get(step: string): any[] | undefined;
-    /** Get a JSON hint string for injecting into Re-Act prompt */
-    getHint(step: string): string | undefined;
+    /** Tokenize a Chinese/mixed step description for fuzzy matching.
+     *  Uses bigram (character pair) extraction for Chinese — more granular than
+     *  whitespace splitting, captures shared sub-phrases like "指标标准名称".
+     */
+    private tokenize;
+    /** Compute Jaccard similarity between two token sets */
+    private jaccard;
+    /** Find the best matching cached entry for a given step description */
+    private findBestMatch;
+    /** Get a hint string for injecting into Re-Act prompt.
+     *  1. Exact match → direct reuse
+     *  2. Fuzzy match by token similarity → similar step reuse
+     *  3. Same-page fallback → if same URL path, use the most recent successful entry
+     */
+    getHint(step: string, currentUrl?: string): string | undefined;
+    /** Extract path portion of URL for same-page matching (ignore query/hash) */
+    private extractPath;
+    /** Format a hint from a cache entry's actions.
+     *  Success: action sequence summary + key discoveries
+     *  Failure: warnings/blockers only — avoid misleading Agent into reusing failed paths
+     */
+    private formatHint;
     /** Get all cached entries */
-    getAll(): Map<string, any[]>;
+    getAll(): Map<string, CacheEntry>;
     /** Clear all cached entries (typically at round start) */
     clear(): void;
 }
 /** Global singleton for same-round sharing */
 export declare const learnedActions: LearnedActions;
+export {};