@kkeve/suite 0.0.12 → 0.0.15

package/dist/commands/run.js

@@ -230,7 +230,10 @@ async function run(options) {
     console.log(chalk_1.default.blue(`  ▶ Round ${round} — Executing Playwright tests...\n`));
     await ensurePlaywrightBrowsers();
     if (!env.KEVE_CDP_ENDPOINT && !env.KEVE_CDP_WS_ENDPOINT) {
-        env.KEVE_CDP_ENDPOINT = 'http://127.0.0.1:9222';
+        // 不再盲目设置 KEVE_CDP_ENDPOINT fallback — 如果 browserSetup() 未成功启动 Chrome，
+        // 这个 fallback 会让 isCdpMode() 返回 true → getCdpBrowser() 去连一个不存在的 CDP → throw
+        // 现在由 getCdpBrowser() 内部处理 graceful fallback 到非 CDP 模式
+        console.log(chalk_1.default.gray('  Note: No CDP endpoint configured — Playwright will launch its own browser'));
     }
     const exitCode = await new Promise((resolve) => {
         const child = (0, node_child_process_1.spawn)('npx', pwArgs, {

package/dist/core/generateReport/reportData.js

@@ -73,9 +73,12 @@ function resolveOptions(opts) {
 //   2. ktest 原始的 TCDPQA100195 / TCDPQA100189 等：「大写字母+数字」连续无分隔
 //      （ktest 命名规则：TC=TestCase DPQA=数据平台QA 100195=序列号）
 function parseCaseIdFromTitle(title) {
-    const colonMatch = title.match(/^([A-Z]+(?:-[A-Z]+)*-\d+|[A-Z]+\d+):/);
-    const bracketMatch = title.match(/\[([A-Z]+(?:-[A-Z]+)*-\d+|[A-Z]+\d+)\]/);
-    const spaceMatch = title.match(/^([A-Z]+(?:-[A-Z]+)*-\d+|[A-Z]+\d+)\s/);
+    // Case ID patterns: "SKILL_SHARE-01:", "AG-01:", "ABC123:", "[REG-02]"
+    // Supports: underscores (SKILL_SHARE), hyphens (REG-01), pure alphanumeric (ABC123)
+    const caseIdPattern = '[A-Z][A-Z0-9]*(?:[_-][A-Z0-9]+)*-\\d+|[A-Z]+\\d+';
+    const colonMatch = title.match(new RegExp(`^(${caseIdPattern}):`));
+    const bracketMatch = title.match(new RegExp(`\\[(${caseIdPattern})\\]`));
+    const spaceMatch = title.match(new RegExp(`^(${caseIdPattern})\\s`));
     return colonMatch?.[1] || bracketMatch?.[1] || spaceMatch?.[1] || null;
 }
 /**

package/dist/core/global-setup.d.ts

@@ -1,6 +1,6 @@
 declare global {
     var __keve_cdp_browser: import('@playwright/test').Browser | undefined;
 }
-export declare function getCdpBrowser(): Promise<import('@playwright/test').Browser>;
+export declare function getCdpBrowser(): Promise<import('@playwright/test').Browser | null>;
 export declare function isCdpMode(): boolean;
 export default function (): Promise<void>;

package/dist/core/global-setup.js

@@ -50,21 +50,30 @@ async function getCdpBrowser() {
     if (!wsUrl && process.env.KEVE_CDP_ENDPOINT) {
         const httpUrl = process.env.KEVE_CDP_ENDPOINT.replace(/\/$/, '');
         try {
-            const resp = await fetch(`${httpUrl}/json/version`);
+            const resp = await fetch(`${httpUrl}/json/version`, { signal: AbortSignal.timeout(5000) });
             const data = await resp.json();
             wsUrl = data.webSocketDebuggerUrl;
             console.log(`[keve CDP] Resolved WS endpoint: ${wsUrl}`);
         }
         catch (e) {
-            throw new Error(`Failed to resolve CDP WebSocket URL from ${httpUrl}: ${e.message}`);
+            console.warn(`[keve CDP] Failed to resolve CDP WebSocket URL from ${httpUrl}: ${e.message} — falling back to non-CDP mode`);
+            return null;
         }
     }
-    if (!wsUrl)
-        throw new Error('No CDP endpoint configured');
-    const browser = await chromium.connectOverCDP(wsUrl, { timeout: 15000 });
-    console.log(`[keve CDP] Connected via ${wsUrl}`);
-    globalThis.__keve_cdp_browser = browser;
-    return browser;
+    if (!wsUrl) {
+        console.warn(`[keve CDP] No CDP endpoint configured — falling back to non-CDP mode`);
+        return null;
+    }
+    try {
+        const browser = await chromium.connectOverCDP(wsUrl, { timeout: 15000 });
+        console.log(`[keve CDP] Connected via ${wsUrl}`);
+        globalThis.__keve_cdp_browser = browser;
+        return browser;
+    }
+    catch (connectErr) {
+        console.warn(`[keve CDP] connectOverCDP failed: ${connectErr.message} — falling back to non-CDP mode`);
+        return null;
+    }
 }
 function isCdpMode() {
     return !!process.env.KEVE_CDP_WS_ENDPOINT || !!process.env.KEVE_CDP_ENDPOINT;
@@ -76,8 +85,9 @@ async function default_1() {
     if (cdpEndpoint) {
         console.log(`[keve global-setup] CDP endpoint detected: ${cdpEndpoint}`);
         // CDP 模式：在 global-setup 中提前连接一次，缓存 Browser 对象
-        try {
-            const browser = await getCdpBrowser();
+        // getCdpBrowser() 失败时返回 null 并清除 CDP 环境变量 → 后续 fixture 自动 fallback
+        const browser = await getCdpBrowser();
+        if (browser) {
             const contexts = browser.contexts();
             const pages = contexts.length > 0 ? contexts[0].pages() : [];
             console.log(`[keve global-setup] CDP connected. contexts=${contexts.length}, pages=${pages.length}`);
@@ -85,8 +95,8 @@ async function default_1() {
                 console.log(`[keve global-setup] Existing tabs: ${pages.map(p => p.url()).join(', ')}`);
             }
         }
-        catch (e) {
-            console.warn(`[keve global-setup] CDP connection failed: ${e.message}`);
+        else {
+            console.warn(`[keve global-setup] CDP connection failed — tests will use non-CDP fallback (chromium.launch)`);
         }
         if (!fs.existsSync(storageStatePath)) {
             const authDir = path.dirname(storageStatePath);

package/dist/core/keve-test.js

@@ -87,9 +87,10 @@ 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) ──
@@ -103,8 +104,17 @@ exports.test = test_1.test.extend({
     browser: async ({}, use, testInfo) => {
         if ((0, global_setup_1.isCdpMode)()) {
             const browser = await (0, global_setup_1.getCdpBrowser)(); // 复用全局共享的 CDP browser
-            await use(browser);
-            // CDP 模式下不关闭浏览器（共享连接，关闭会影响后续用例）
+            if (browser) {
+                await use(browser);
+                // CDP 模式下不关闭浏览器（共享连接，关闭会影响后续用例）
+            }
+            else {
+                // CDP 不可达 → graceful fallback 到独立启动浏览器
+                console.log(`[keve-test] CDP unavailable, falling back to chromium.launch()`);
+                const fallback = await test_1.chromium.launch(testInfo.project?.use?.launchOptions || {});
+                await use(fallback);
+                await fallback.close();
+            }
         }
         else {
             const browser = await test_1.chromium.launch(testInfo.project?.use?.launchOptions || {});
@@ -113,7 +123,8 @@ exports.test = test_1.test.extend({
         }
     },
     page: async ({ browser }, use) => {
-        if ((0, global_setup_1.isCdpMode)()) {
+        const isCdp = (0, global_setup_1.isCdpMode)() && browser.isConnected();
+        if (isCdp) {
             const contexts = browser.contexts();
             const cdpContext = contexts.length > 0 ? contexts[0] : await browser.newContext();
             // CDP 模式：优先复用已有 page（保留登录状态），仅在无可用 page 时新开
@@ -202,7 +213,8 @@ exports.test = test_1.test.extend({
                 catch { /* non-critical */ }
             }
             // ── Hand off to agent: agent does Re-Act (OR shortcut to blocked if fnBlocked) ──
-            const learnedHint = learned_actions_1.learnedActions.getHint(options.step);
+            const currentUrl = page.url();
+            const learnedHint = learned_actions_1.learnedActions.getHint(options.step, currentUrl);
             let reactResult;
             let reactTimedOut = false;
             if (fnBlocked) {
@@ -222,43 +234,69 @@ exports.test = test_1.test.extend({
                 };
             }
             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);
+                // ── Page liveness check: if fn killed the page, skip Agent Re-Act ──
+                // When fn error involves page/browser close, the page is dead —
+                // Agent cannot take a11y snapshots or interact. Skip immediately.
+                let pageAlive = true;
                 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,
-                    });
+                    await page.url();
+                }
+                catch {
+                    pageAlive = false;
                 }
-                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 (!pageAlive) {
+                    console.log(`[keveGoal] 🚫 "${options.step}" BLOCKED — page is dead after fn error, skipping agent Re-Act`);
                     reactResult = {
                         expectedMet: false,
-                        actions: [],
+                        actions: [{
+                                action: { tool: 'done', verdict: 'blocked', text: `Page closed after fn error: ${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 page-alive else (agent Re-Act path)
             } // 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
@@ -464,6 +502,16 @@ function isEnvironmentBlockedError(err) {
         || msg.includes('err_too_many_redirects')) {
         return true;
     }
+    // Page/context/browser closed — dead page, Agent cannot explore
+    // e.g. "page.waitForLoadState: Target page, context or browser has been closed"
+    // e.g. "page.ariaSnapshot: Target page, context or browser has been closed"
+    // When the CDP connection drops or the user closes the tab, any page API throws this.
+    // Agent Re-Act on a dead page is a waste of time → BLOCKED immediately.
+    if (msg.includes('target page, context or browser has been closed')
+        || msg.includes('page has been closed') || msg.includes('browser has been closed')
+        || msg.includes('context has been closed')) {
+        return true;
+    }
     return false;
 }
 /**

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 {};

package/dist/core/learned-actions.js

@@ -5,51 +5,243 @@
  * 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.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.learnedActions = exports.LearnedActions = void 0;
 class LearnedActions {
     cache = new Map();
-    /** Store discovered actions for a step */
-    add(step, actions) {
-        // Only store successful action sequences (ending with expected met)
+    /** 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, actions, url, success = true) {
         if (actions.length > 0) {
-            this.cache.set(step, actions);
+            this.cache.set(step, { step, actions, url, success });
         }
     }
-    /** Retrieve discovered actions for a step */
+    /** Retrieve discovered actions for a step (exact match) */
     get(step) {
-        return this.cache.get(step);
+        return this.cache.get(step)?.actions;
     }
-    /** Get a JSON hint string for injecting into Re-Act prompt */
-    getHint(step) {
-        const actions = this.cache.get(step);
-        if (!actions || actions.length === 0)
-            return undefined;
-        // Summarize: only include action type + role/name, not full snapshot
+    /** 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 "指标标准名称".
+     */
+    tokenize(text) {
+        // 1. Split by delimiters to get chunks
+        const chunks = text
+            .replace(/[，。、；：""''（）【】《》\s,.;:!?/\\|]+/g, ' ')
+            .split(' ')
+            .filter(t => t.length > 0);
+        // 2. For each chunk, extract character bigrams (for Chinese sub-phrase matching)
+        //    AND keep the original chunk (for exact chunk matches)
+        const tokens = [];
+        for (const chunk of chunks) {
+            tokens.push(chunk.toLowerCase());
+            // Generate bigrams: sliding window of 2 chars
+            for (let i = 0; i < chunk.length - 1; i++) {
+                tokens.push(chunk.substring(i, i + 2).toLowerCase());
+            }
+        }
+        return tokens;
+    }
+    /** Compute Jaccard similarity between two token sets */
+    jaccard(a, b) {
+        const setA = new Set(a.map(t => t.toLowerCase()));
+        const setB = new Set(b.map(t => t.toLowerCase()));
+        const intersection = [...setA].filter(t => setB.has(t)).length;
+        const union = new Set([...setA, ...setB]).size;
+        return union === 0 ? 0 : intersection / union;
+    }
+    /** Find the best matching cached entry for a given step description */
+    findBestMatch(step) {
+        const tokens = this.tokenize(step);
+        let bestEntry;
+        let bestScore = 0;
+        // Threshold: 18% token overlap — low enough to catch "填写其他必填项" vs "必填项填入合法值",
+        // high enough to avoid completely unrelated steps matching
+        const THRESHOLD = 0.18;
+        for (const [, entry] of this.cache) {
+            const entryTokens = this.tokenize(entry.step);
+            const score = this.jaccard(tokens, entryTokens);
+            if (score > bestScore && score >= THRESHOLD) {
+                bestScore = score;
+                bestEntry = entry;
+            }
+        }
+        return bestEntry;
+    }
+    /** 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, currentUrl) {
+        // 1. Try exact match first (prefer success entries over failures)
+        const exact = this.cache.get(step);
+        if (exact?.actions.length) {
+            const hint = this.formatHint(exact.step, exact.actions, false, exact.success);
+            if (hint)
+                return hint;
+        }
+        // 2. Fuzzy match by step description similarity (prefer success, but include failures)
+        const best = this.findBestMatch(step);
+        if (best?.actions.length) {
+            const hint = this.formatHint(best.step, best.actions, true, best.success);
+            if (hint)
+                return hint;
+        }
+        // 3. Same-page fallback: if on the same URL path as a cached entry, use the most
+        //    relevant one (highest Jaccard, even if below fuzzy threshold).
+        //    Minimum Jaccard = 0.08 to avoid completely unrelated steps on the same page.
+        if (currentUrl) {
+            const urlPath = this.extractPath(currentUrl);
+            let bestSamePage;
+            let bestSamePageScore = 0;
+            const SAME_PAGE_MIN = 0.08;
+            const stepTokens = this.tokenize(step);
+            for (const [, entry] of this.cache) {
+                if (entry.url && this.extractPath(entry.url) === urlPath) {
+                    const entryTokens = this.tokenize(entry.step);
+                    const score = this.jaccard(stepTokens, entryTokens);
+                    if (score > bestSamePageScore && score >= SAME_PAGE_MIN) {
+                        bestSamePageScore = score;
+                        bestSamePage = entry;
+                    }
+                }
+            }
+            if (bestSamePage?.actions.length) {
+                const hint = this.formatHint(bestSamePage.step, bestSamePage.actions, true, bestSamePage.success);
+                if (hint)
+                    return hint;
+            }
+        }
+        return undefined;
+    }
+    /** Extract path portion of URL for same-page matching (ignore query/hash) */
+    extractPath(url) {
+        try {
+            const u = new URL(url);
+            return u.pathname;
+        }
+        catch {
+            return url;
+        }
+    }
+    /** 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
+     */
+    formatHint(sourceStep, actions, isFuzzy, success) {
+        if (!success) {
+            // Failed step — surface warnings/blockers AND combobox conflict info
+            const discoveries = [];
+            for (const a of actions) {
+                const out = a.toolOutput || '';
+                if (out.startsWith('⚠️'))
+                    discoveries.push(out.slice(0, 120));
+                // Also capture combobox "重复" conflicts — valuable for later goals to avoid same data
+                if (out.includes('重复') || out.includes('duplicate') || out.includes('conflict')) {
+                    discoveries.push(`DATA CONFLICT: ${out.slice(0, 120)}`);
+                }
+            }
+            if (discoveries.length === 0)
+                return undefined;
+            const prefix = isFuzzy
+                ? `Previous FAILED step SIMILAR to "${sourceStep}"`
+                : `Previous FAILED step "${sourceStep}"`;
+            return `${prefix} — avoid these approaches. Blocked by: ${discoveries.slice(-3).map(d => `[${d}]`).join('; ')}`;
+        }
+        // Success — full action sequence + discoveries (existing logic)
+        // Extract stable element identity from toolOutput (not from action fields which lack role/name)
         const summary = actions
-            .filter(a => a.action.tool !== 'done')
+            .filter(a => a.action?.tool !== 'done' && a.tool !== 'done')
             .map(a => {
-            const act = a.action;
+            const act = a.action || a;
+            const out = a.toolOutput || '';
             if (act.tool === 'navigate')
                 return `navigate(${act.url})`;
-            if (act.tool === 'click')
-                return `click(${act.role} "${act.name}")`;
-            if (act.tool === 'type')
-                return `type(${act.role} "${act.name}", "${act.text}"${act.submit ? ', Enter' : ''})`;
+            if (act.tool === 'click') {
+                // Parse toolOutput: "✅ Clicked [ref=e688] button \"新增指标\"" → "button 新增指标"
+                // or: "⚠️ Clicked [ref=e2843] button \"确定\" — dialog still open" → "button 确定"
+                const descMatch = out.match(/Clicked \[ref=\w+\]\s+(\S+\s+"[^"]*"|\S+)/);
+                if (descMatch) {
+                    // descMatch[1] = 'button "新增指标"' or 'button "确定"' or 'element'
+                    const clean = descMatch[1].replace(/"/g, '').trim();
+                    return `click(${clean})`;
+                }
+                return `click(?)`;
+            }
+            if (act.tool === 'type') {
+                // Parse toolOutput for stable type info
+                const typeMatch = out.match(/✅ (replace|append) "([^"]*)" into element \[ref=\w+\]/);
+                if (typeMatch)
+                    return `type("${typeMatch[2].slice(0, 30)}"${typeMatch[1] === 'append' ? ', append' : ''})`;
+                // Combobox selection
+                const cbMatch = out.match(/✅ Selected "([^"]*)" in combobox/);
+                if (cbMatch)
+                    return `select("${cbMatch[1].slice(0, 30)}")`;
+                return `type(?)`;
+            }
+            if (act.tool === 'fill_form') {
+                // Extract filled fields from multi-line toolOutput
+                // Lines look like: "✅ textbox [e2755] = "测试指标标准名称"" or "✅ combobox [e2800] = "KwaiBI官方数据集DEMO" (custom)"
+                const fields = [];
+                for (const line of out.split('\n')) {
+                    const fieldMatch = line.match(/✅ (\w+) \[\w+\] = "?([^"]*?)"?\s*(\(custom\))?$/);
+                    if (fieldMatch && fieldMatch[2]) {
+                        const fType = fieldMatch[1];
+                        const fVal = fieldMatch[2].slice(0, 25);
+                        fields.push(`${fType}="${fVal}"`);
+                    }
+                }
+                return fields.length ? `fill_form(${fields.join(', ')})` : 'fill_form(...)';
+            }
+            if (act.tool === 'select_option') {
+                const selMatch = out.match(/✅ Selected "([^"]*)"/);
+                if (selMatch)
+                    return `select_option("${selMatch[1].slice(0, 30)}")`;
+                return `select_option(?)`;
+            }
             if (act.tool === 'hover')
-                return `hover(${act.role} "${act.name}")`;
+                return `hover(${act.role || ''} "${act.name || ''}")`;
             if (act.tool === 'pressKey')
                 return `pressKey(${act.key})`;
             if (act.tool === 'scroll')
                 return `scroll(${act.direction})`;
             if (act.tool === 'wait')
                 return `wait(${act.time}ms)`;
+            if (act.tool === 'execute_javascript') {
+                const jsResult = out.match(/✅ JS executed\. Result: (.+)/);
+                if (jsResult)
+                    return `js(→ ${jsResult[1].slice(0, 40)})`;
+                return 'js(?)';
+            }
             return act.tool;
         });
-        return `Previous successful actions for "${step}": ${summary.join(' → ')}`;
+        // Extract key toolOutput lines — discoveries that other goals need to know
+        // Focus on: combobox option results (✅/❌), dialog warnings (⚠️), validation messages
+        const discoveries = [];
+        for (const a of actions) {
+            const out = a.toolOutput || '';
+            // Combobox option selection results (most valuable for form reuse)
+            if (out.includes('combobox') && (out.includes('(custom)') || out.includes('could not find option'))) {
+                discoveries.push(out.slice(0, 120));
+            }
+            // Dialog warnings that blocked submission
+            if (out.startsWith('⚠️')) {
+                discoveries.push(out.slice(0, 120));
+            }
+        }
+        // Limit to 5 most important discoveries
+        const discoveryLines = discoveries.length > 0
+            ? `\nKey discoveries: ${discoveries.slice(-5).map(d => `[${d}]`).join('; ')}`
+            : '';
+        const prefix = isFuzzy
+            ? `Previous successful actions for SIMILAR step "${sourceStep}"`
+            : `Previous successful actions for "${sourceStep}"`;
+        return `${prefix}: ${summary.join(' → ')}${discoveryLines}`;
     }
     /** Get all cached entries */
     getAll() {

package/dist/page-agent/agent.d.ts

@@ -85,6 +85,19 @@ export declare class KevePageAgent {
     /** Current execute options (set at start of execute(), accessible from hooks) */
     options?: AgentOptions;
     private hooks?;
+    _dialogHandler: {
+        accept: boolean;
+        promptText?: string;
+    } | null;
+    _lastDialogInfo: {
+        type: string;
+        message: string;
+        accepted: boolean;
+    } | null;
+    _pendingFileChooser: any;
+    _consoleMessages: any[];
+    _networkRequests: any[];
+    _pageListenersSetup: boolean;
     constructor(page: Page, options?: {
         maxSteps?: number;
         customSystemPrompt?: string;
@@ -92,6 +105,9 @@ export declare class KevePageAgent {
     });
     /** Stop the current execution */
     stop(): void;
+    /** Set up page event listeners for dialog, console, network, and file chooser capture.
+     *  Called once per page; subsequent calls are no-ops. */
+    private setupPageListeners;
     /** Main Re-Act execute loop */
     execute(step: string, expected: string, options?: AgentOptions): Promise<AgentResult>;
     private pushObservation;
@@ -110,6 +126,11 @@ export declare class KevePageAgent {
         bbox?: number[];
         analysis?: string;
     }>;
+    /** Visual assertion: check a visual condition without interacting with the page */
+    visualAssertElement(screenshotBase64: string, assertion: string): Promise<{
+        passed: boolean;
+        reasoning: string;
+    }>;
     /** Build final result */
     private buildResult;
 }