@kkeve/suite 0.0.1 → 0.0.2

package/dist/core/keve-test.js

@@ -0,0 +1,364 @@
+"use strict";
+/**
+ * keve-test — Playwright test fixture: keveGoal (唯一操作原语)
+ *
+ * keveGoal 执行 fn 后 → 截图+fn逻辑+expected → AI判断是否一致
+ *   一致     → 通过
+ *   不一致   → AI 告诉你还差什么 → Re-Act 探索 → 探索成功
+ *   fn 无    → Re-Act 直接探索
+ *   fn 异常  → Re-Act 自愈
+ *
+ * keveAssert 已被吸收：keveGoal 的 expected 即断言语义
+ *
+ * Usage:
+ *   import { test, expect } from '@ks-data/keve-suite/keve-test';
+ *
+ *   test('my test', async ({ page, keveGoal }) => {
+ *     await keveGoal({ step: '导航到列表页', expected: '页面加载完成' }, async () => {
+ *       await page.goto('/agents');
+ *     });
+ *
+ *     // AI explore (no fn):
+ *     await keveGoal({ step: '点击新建按钮', expected: '弹出创建对话框' });
+ *   });
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.test = exports.sceneGoalsMap = exports.sceneEvalMetaMap = exports.sceneCodeMap = exports.getModelScenes = exports.keveScene = exports.keveModel = exports.expect = void 0;
+const test_1 = require("@playwright/test");
+Object.defineProperty(exports, "expect", { enumerable: true, get: function () { return test_1.expect; } });
+const keve_registry_1 = require("./keve-registry");
+const agent_1 = require("../page-agent/agent");
+const keve_aspect_1 = require("./keve-aspect");
+const learned_actions_1 = require("./learned-actions");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+// ─── CDP Mode ──────────────────────────────────────────────────────
+// CDP 连接逻辑已移到 global-setup.ts，通过全局变量共享 Browser 对象
+const global_setup_1 = require("./global-setup");
+var keve_decorators_1 = require("./keve-decorators");
+Object.defineProperty(exports, "keveModel", { enumerable: true, get: function () { return keve_decorators_1.keveModel; } });
+Object.defineProperty(exports, "keveScene", { enumerable: true, get: function () { return keve_decorators_1.keveScene; } });
+Object.defineProperty(exports, "getModelScenes", { enumerable: true, get: function () { return keve_decorators_1.getModelScenes; } });
+var keve_registry_2 = require("./keve-registry");
+Object.defineProperty(exports, "sceneCodeMap", { enumerable: true, get: function () { return keve_registry_2.sceneCodeMap; } });
+Object.defineProperty(exports, "sceneEvalMetaMap", { enumerable: true, get: function () { return keve_registry_2.sceneEvalMetaMap; } });
+// Re-export goal metadata for consumer convenience
+var keve_registry_3 = require("./keve-registry");
+Object.defineProperty(exports, "sceneGoalsMap", { enumerable: true, get: function () { return keve_registry_3.sceneGoalsMap; } });
+// ─── Register Built-in Aspects ───────────────────────────────────────
+// NOTE: action-log-write aspect 已废弃。
+// AI 探索过程数据现在通过 keveGoalResult attachment 直接流到 KeveReporter，
+// 由 KeveReporter 统一写入 confidence-data.jsonl（含 reactSteps）。
+keve_aspect_1.keveAspect.register({
+    name: 'learnedActions-update',
+    phase: 'after',
+    order: 20,
+    async execute(ctx, result) {
+        if (!result?.actions?.length || !result.success)
+            return;
+        learned_actions_1.learnedActions.add(ctx.step, result.actions);
+    },
+});
+// ─── (diagnostic extraction moved to page-agent/diagnostic.ts, called via onAfterTask hook) ──
+// ─── Fixture ────────────────────────────────────────────────────────
+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 模式下不关闭浏览器（共享连接，关闭会影响后续用例）
+        }
+        else {
+            const browser = await test_1.chromium.launch(testInfo.project?.use?.launchOptions || {});
+            await use(browser);
+            await browser.close();
+        }
+    },
+    page: async ({ browser }, use) => {
+        if ((0, global_setup_1.isCdpMode)()) {
+            const contexts = browser.contexts();
+            const cdpContext = contexts.length > 0 ? contexts[0] : await browser.newContext();
+            // CDP 模式：优先复用已有 page（保留登录状态），仅在无可用 page 时新开
+            const existingPages = cdpContext.pages();
+            let page;
+            if (existingPages.length > 0) {
+                // 复用第一个非 about:blank 的 page（通常是用户已登录的 tab）
+                page = existingPages.find(p => p.url() !== 'about:blank') || existingPages[0];
+                // 导航到 about:blank 作为起始页（清空之前的状态，但保留 cookie）
+                try {
+                    await page.goto('about:blank', { timeout: 3000 });
+                }
+                catch { /* ignore */ }
+            }
+            else {
+                page = await cdpContext.newPage();
+            }
+            await use(page);
+            // CDP 模式下不关闭 page（保留浏览器 tab 给下一个用例复用）
+        }
+        else {
+            const page = await browser.newPage();
+            await use(page);
+            await page.close();
+        }
+    },
+    // ── keveGoal: 唯一操作原语 ────────────────────────────────────────
+    keveGoal: async ({ page }, use, testInfo) => {
+        let goalOrder = 0;
+        const keveGoalFn = async (options, fn) => {
+            const goalMeta = {
+                precondition: options.precondition,
+                step: options.step,
+                expected: options.expected,
+                order: goalOrder++,
+            };
+            const sceneTitle = testInfo.title;
+            if (!keve_registry_1.sceneGoalsMap.has(sceneTitle))
+                keve_registry_1.sceneGoalsMap.set(sceneTitle, []);
+            keve_registry_1.sceneGoalsMap.get(sceneTitle).push(goalMeta);
+            const ctx = {
+                page,
+                step: options.step,
+                expected: options.expected,
+                precondition: options.precondition,
+                order: goalMeta.order,
+                testTitle: sceneTitle,
+                specFilePath: testInfo.file,
+            };
+            // Run before aspects
+            await keve_aspect_1.keveAspect.runPhase('before', ctx);
+            let result;
+            const fnSource = fn?.toString() || undefined;
+            let fnError;
+            if (fn) {
+                try {
+                    await fn();
+                    console.log(`[keveGoal] "${options.step}" fn executed`);
+                }
+                catch (err) {
+                    fnError = err?.message || String(err);
+                    console.log(`[keveGoal] "${options.step}" fn error: ${fnError}`);
+                }
+            }
+            // ── Capture "before" screenshot (page state before agent starts) ──
+            let goalScreenshotBefore = '';
+            try {
+                const buf = await page.screenshot({ type: 'png', timeout: 15000 });
+                const taskDir = process.env.KEVE_TASK_DIR || '.keve';
+                const round = process.env.KEVE_ROUND || 'latest';
+                const screenshotsDir = path.join(taskDir, 'test-artifacts', `round-${round}`, 'screenshots');
+                fs.mkdirSync(screenshotsDir, { recursive: true });
+                const safeName = options.step.replace(/[^a-zA-Z0-9\u4e00-\u9fff]/g, '_').slice(0, 30);
+                const file = path.join(screenshotsDir, `goal-before-${goalMeta.order}-${safeName}-${Date.now()}.png`);
+                fs.writeFileSync(file, buf);
+                goalScreenshotBefore = path.relative(taskDir, file);
+            }
+            catch { /* non-critical */ }
+            // ── Hand off to agent: agent does Re-Act ──
+            const learnedHint = learned_actions_1.learnedActions.getHint(options.step);
+            let reactResult;
+            let reactTimedOut = false;
+            // ── Per-goal timeout: prevent one slow goal from exhausting the test timeout ──
+            // Default 120s per goal; total test timeout should be ≥ (goals × 120s + overhead)
+            const GOAL_TIMEOUT_MS = 120_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,
+                });
+            }
+            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);
+            }
+            result = {
+                success: reactResult.expectedMet,
+                actions: reactResult.actions,
+                finalSnapshot: reactResult.finalSnapshot,
+                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}`),
+            };
+            // Attach Agent conclusion for downstream consumers
+            if (reactResult.conclusion)
+                result.conclusion = reactResult.conclusion;
+            console.log(reactResult.expectedMet
+                ? `[keveGoal] ✅ "${options.step}" PASSED`
+                : `[keveGoal] ❌ "${options.step}" FAILED (${reactResult.conclusion || 'fail'}) — ${result.error?.message || 'expected not achieved'}`);
+            // if (reactResult.refinePatch) (result as any).refinePatch = reactResult.refinePatch; // 已注释：scriptRefine 已禁用
+            if (reactResult.agentScreenshots)
+                result.agentScreenshots = reactResult.agentScreenshots;
+            // ── 核心：在 keveGoal 内部、throw 之前，写 attachment ──
+            // AI 探索的完整数据（actions、diagnosticHint）
+            // 通过 Playwright attachment 流到 KeveReporter.onTestEnd
+            // 注意：screenshotBase64 不再写入 attachment（截图已保存到文件系统，路径见 goalScreenshotBefore/goalScreenshotAfter）
+            const diagnosticHints = reactResult.diagnosticHints || [];
+            let goalScreenshotAfter = '';
+            try {
+                const buf = await page.screenshot({ type: 'png', timeout: 15000 });
+                const taskDir = process.env.KEVE_TASK_DIR || '.keve';
+                const round = process.env.KEVE_ROUND || 'latest';
+                const screenshotsDir = path.join(taskDir, 'test-artifacts', `round-${round}`, 'screenshots');
+                fs.mkdirSync(screenshotsDir, { recursive: true });
+                const safeName = options.step.replace(/[^a-zA-Z0-9\u4e00-\u9fff]/g, '_').slice(0, 30);
+                const file = path.join(screenshotsDir, `goal-after-${goalMeta.order}-${safeName}-${Date.now()}.png`);
+                fs.writeFileSync(file, buf);
+                goalScreenshotAfter = path.relative(taskDir, file);
+                console.log(`[keveGoal] screenshot captured: ${buf.length} bytes (path: ${goalScreenshotAfter})`);
+            }
+            catch (e) {
+                console.log(`[keveGoal] screenshot failed: ${e.message}`);
+            }
+            await testInfo.attach('keveGoalResult', {
+                contentType: 'application/json',
+                body: Buffer.from(JSON.stringify({
+                    step: options.step,
+                    expected: options.expected,
+                    precondition: options.precondition,
+                    order: goalMeta.order,
+                    success: result.success,
+                    actions: (result.actions || []).map((a) => {
+                        // Derive done action conclusion reliably (4-level backoff):
+                        // - Level 1: step-level conclusion (from agent.ts, handles verdict/result/success/text)
+                        // - Level 2: a.action?.verdict (new, no schema conflict)
+                        // - Level 3: a.action?.result if it's a valid 3-state value
+                        // - Level 4: a.action?.success (legacy boolean) or text parsing
+                        // Do NOT use a.action?.result blindly (MacroTool schema conflict: "ok" ≠ "pass")
+                        const actionTool = a.action?.tool;
+                        let actionConclusion;
+                        if (actionTool === 'done') {
+                            if (result.conclusion) {
+                                actionConclusion = result.conclusion;
+                            }
+                            else {
+                                const verdict = a.action?.verdict;
+                                if (verdict === 'pass' || verdict === 'fail' || verdict === 'blocked') {
+                                    actionConclusion = verdict;
+                                }
+                                else {
+                                    const raw = a.action?.result;
+                                    if (raw === 'pass' || raw === 'fail' || raw === 'blocked')
+                                        actionConclusion = raw;
+                                    else if (typeof a.action?.success === 'boolean')
+                                        actionConclusion = a.action.success ? 'pass' : 'fail';
+                                    else {
+                                        // Level 4: parse text for verdict keyword (includes match, not exact)
+                                        // IMPORTANT: Check fail/blocked BEFORE pass to avoid "不通过" hitting "通过"
+                                        const tv = String(a.action?.text || '').trim().toLowerCase();
+                                        if (tv.includes('fail') || tv.includes('failure')
+                                            || tv.includes('失败') || tv.includes('未通过') || tv.includes('不通过'))
+                                            actionConclusion = 'fail';
+                                        else if (tv.includes('blocked') || tv.includes('阻塞') || tv.includes('阻止'))
+                                            actionConclusion = 'blocked';
+                                        else if (tv.includes('pass') || tv.includes('success') || tv.includes('ok')
+                                            || tv.includes('完成') || tv.includes('成功') || tv.includes('通过') || tv.includes('验证通过'))
+                                            actionConclusion = 'pass';
+                                    }
+                                }
+                            }
+                        }
+                        return {
+                            tool: actionTool,
+                            role: a.action?.role,
+                            name: a.action?.name,
+                            url: a.action?.url,
+                            text: a.action?.text,
+                            toolOutput: a.toolOutput?.slice(0, 500),
+                            reason: a.action?.reason,
+                            success: a.action?.success,
+                            // Agent 3-state verdict (pass/fail/blocked) — new field, no schema conflict
+                            verdict: a.action?.verdict,
+                            // Agent 3-state conclusion (pass/fail/blocked) — reliably derived
+                            conclusion: actionConclusion,
+                            result: a.result,
+                            error: a.error,
+                            evaluation: a.evaluation?.slice(0, 300),
+                            memory: a.memory?.slice(0, 200),
+                            nextGoal: a.nextGoal?.slice(0, 200),
+                            screenshotPath: a.screenshotPath,
+                        };
+                    }),
+                    finalSnapshot: result.finalSnapshot ? String(result.finalSnapshot).slice(0, 500) : undefined,
+                    diagnosticHints,
+                    goalScreenshotBefore: goalScreenshotBefore || undefined,
+                    goalScreenshotAfter: goalScreenshotAfter || undefined,
+                    agentScreenshots: result.agentScreenshots || [],
+                    // refinePatch: (result as any).refinePatch || undefined, // 已注释：scriptRefine 已禁用
+                    conclusion: result.conclusion || undefined,
+                }), 'utf-8'),
+            });
+            // Run after aspects
+            await keve_aspect_1.keveAspect.runPhase('after', ctx, result, result.error);
+            // Throw if not successful
+            if (!result.success) {
+                const failReason = result.error?.message || 'expected state not achieved';
+                console.log(`[keveGoal] ❌ "${options.step}" FAILED — reason: ${failReason}`);
+                throw result.error || new Error(`keveGoal "${options.step}" failed: ${failReason}`);
+            }
+        };
+        await use(keveGoalFn);
+        // keveGoals attachment 已删除：step/expected/precondition/order 已合并进
+        // keveGoalResult attachment，不再单独输出 keveGoals 附件
+        // sceneGoalsMap 保留供内部分类使用
+    }
+});
+// Register extended test with keve-decorators so @keveModel uses the correct test
+const keve_decorators_2 = require("./keve-decorators");
+(0, keve_decorators_2.setKeveTest)(exports.test);

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

@@ -0,0 +1,24 @@
+/**
+ * learned-actions — In-memory cache for same-round Re-Act discovery sharing
+ *
+ * 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
+ */
+export declare class LearnedActions {
+    private cache;
+    /** Store discovered actions for a step */
+    add(step: string, actions: any[]): void;
+    /** Retrieve discovered actions for a step */
+    get(step: string): any[] | undefined;
+    /** Get a JSON hint string for injecting into Re-Act prompt */
+    getHint(step: string): string | undefined;
+    /** Get all cached entries */
+    getAll(): Map<string, any[]>;
+    /** Clear all cached entries (typically at round start) */
+    clear(): void;
+}
+/** Global singleton for same-round sharing */
+export declare const learnedActions: LearnedActions;

package/dist/core/learned-actions.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * learned-actions — In-memory cache for same-round Re-Act discovery sharing
+ *
+ * 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
+ */
+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)
+        if (actions.length > 0) {
+            this.cache.set(step, actions);
+        }
+    }
+    /** Retrieve discovered actions for a step */
+    get(step) {
+        return this.cache.get(step);
+    }
+    /** 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
+        const summary = actions
+            .filter(a => a.action.tool !== 'done')
+            .map(a => {
+            const act = a.action;
+            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 === 'hover')
+                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)`;
+            return act.tool;
+        });
+        return `Previous successful actions for "${step}": ${summary.join(' → ')}`;
+    }
+    /** Get all cached entries */
+    getAll() {
+        return this.cache;
+    }
+    /** Clear all cached entries (typically at round start) */
+    clear() {
+        this.cache.clear();
+    }
+}
+exports.LearnedActions = LearnedActions;
+/** Global singleton for same-round sharing */
+exports.learnedActions = new LearnedActions();

package/dist/core/pw-config.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Playwright config template generator
+ *
+ * Shared by `keve config`, `keve init`, and pipeline agents
+ * to produce consistent keve-test.config.{ts,mjs} files.
+ */
+export interface PwConfigOptions {
+    baseUrl?: string;
+    cdp?: boolean;
+    cdpEndpoint?: string;
+    webServer?: boolean;
+    workers?: number;
+    timeout?: number;
+    retries?: number;
+    format?: 'ts' | 'mjs';
+}
+export declare function generatePwConfig(options?: PwConfigOptions): string;
+export declare function resolveConfigOutputPath(explicitOutput?: string, format?: 'ts' | 'mjs'): string;
+export declare function findExistingConfig(keveDir: string | null, taskDir: string | null): string | null;

package/dist/core/pw-config.js

@@ -0,0 +1,180 @@
+"use strict";
+/**
+ * Playwright config template generator
+ *
+ * Shared by `keve config`, `keve init`, and pipeline agents
+ * to produce consistent keve-test.config.{ts,mjs} files.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePwConfig = generatePwConfig;
+exports.resolveConfigOutputPath = resolveConfigOutputPath;
+exports.findExistingConfig = findExistingConfig;
+const path = __importStar(require("node:path"));
+const config_1 = require("../config");
+function generatePwConfig(options = {}) {
+    const { baseUrl, cdp = false, cdpEndpoint, webServer = !cdp, workers = 3, timeout = 1200000, retries = 0, format = 'ts', } = options;
+    const baseURLLine = baseUrl
+        ? `process.env.BASE_URL || '${baseUrl}'`
+        : `process.env.BASE_URL || process.env.PWGEN_TARGET_URL || 'http://localhost:3000'`;
+    const cdpBlock = cdp
+        ? `\n    // CDP: connect to running Chrome (preserves login state)\n    // Set KEVE_CDP_ENDPOINT=http://[::1]:9222 at runtime\n    // Or:  KEVE_CDP_WS_ENDPOINT=ws://...\n    connectOptions: ${cdpEndpoint ? `{ endpoint: '${cdpEndpoint}' }` : `process.env.KEVE_CDP_ENDPOINT ? { endpoint: process.env.KEVE_CDP_ENDPOINT } : undefined`},`
+        : '';
+    const webServerBlock = webServer
+        ? `\n  webServer: {\n    command: 'pnpm dev',\n    url: ${baseUrl ? `'${baseUrl}'` : `'http://localhost:3000'`},\n    reuseExistingServer: true,\n  },`
+        : `\n  // webServer disabled — CDP mode assumes app is already running`;
+    if (format === 'mjs') {
+        return generateMjsConfig({ baseURLLine, cdp, cdpBlock, webServerBlock, workers, timeout, retries });
+    }
+    return `import { defineConfig } from '@playwright/test';
+import * as path from 'node:path';
+
+const projectRoot = path.resolve(__dirname, '..');
+
+// Task directory — set KEVE_TASK_DIR env at execution time
+// e.g. KEVE_TASK_DIR=.keve/task_xxx npx playwright test --config=.keve/task_xxx/keve-test.config.ts
+const taskDir = process.env.KEVE_TASK_DIR
+  ? path.resolve(projectRoot, process.env.KEVE_TASK_DIR)
+  : path.resolve(projectRoot, '.keve/default');
+
+const round = process.env.KEVE_ROUND || 'latest';
+const resultDir = path.join(taskDir, 'test-artifacts', \`round-\${round}\`);
+
+export default defineConfig({
+  globalSetup: require.resolve('@ks-data/keve-suite/global-setup'),
+  testDir: path.join(taskDir, 'keve_test_spec'),
+  fullyParallel: true,
+  workers: ${workers},
+  retries: ${retries},
+  timeout: ${timeout},
+  expect: { timeout: 10000 },
+  reporter: [
+    ['list'],
+    ['json', { outputFile: path.join(resultDir, 'test-results.json') }],
+    [require.resolve('@ks-data/keve-suite/keve-report')],
+  ],
+  use: {
+    baseURL: ${baseURLLine},${cdp ? `\n    // CDP mode: login state preserved via connected Chrome` : `\n    storageState: path.resolve(projectRoot, '.auth/storage-state.json'),`}
+    trace: 'on-first-retry',
+    screenshot: 'only-on-failure',
+    video: 'retain-on-failure',
+    actionTimeout: 5000,${cdpBlock}
+  },
+  outputDir: path.join(resultDir, 'test-results'),${webServerBlock}
+});
+`;
+}
+function generateMjsConfig(params) {
+    const { baseURLLine, cdp, cdpBlock, webServerBlock, workers, timeout, retries } = params;
+    const keveSuiteDir = `resolve(dirname(fileURLToPath(import.meta.url)), '..', 'node_modules', '@ks-data', 'keve-suite')`;
+    const globalSetupExpr = `resolve(${keveSuiteDir}, 'global-setup.js')`;
+    const keveReportExpr = `resolve(${keveSuiteDir}, 'keve-report.js')`;
+    return `import { defineConfig } from '@playwright/test';
+import { resolve, join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const projectRoot = resolve(__dirname, '..');
+
+const taskDir = process.env.KEVE_TASK_DIR
+  ? resolve(projectRoot, process.env.KEVE_TASK_DIR)
+  : resolve(projectRoot, '.keve/default');
+
+process.env.KEVE_TASK_DIR = taskDir;
+
+const round = process.env.KEVE_ROUND || 'latest';
+const resultDir = join(taskDir, 'test-artifacts', \`round-\${round}\`);
+
+const globalSetup = ${globalSetupExpr};
+const keveReporter = ${keveReportExpr};
+
+export default defineConfig({
+  globalSetup,
+  testDir: join(taskDir, 'keve_test_spec'),
+  fullyParallel: true,
+  workers: ${workers},
+  retries: ${retries},
+  timeout: ${timeout},
+  expect: { timeout: 10000 },
+  reporter: [
+    ['list'],
+    ['json', { outputFile: join(resultDir, 'test-results.json') }],
+    [keveReporter],
+  ],
+  use: {
+    baseURL: ${baseURLLine},${cdp ? `\n    // CDP mode: login state preserved via connected Chrome` : `\n    storageState: resolve(projectRoot, '.auth', 'storage-state.json'),`}
+    trace: 'on-first-retry',
+    screenshot: 'only-on-failure',
+    video: 'retain-on-failure',
+    actionTimeout: 5000,${cdpBlock}
+  },
+  outputDir: join(resultDir, 'test-results'),${webServerBlock}
+});
+`;
+}
+function resolveConfigOutputPath(explicitOutput, format = 'ts') {
+    const ext = format === 'mjs' ? '.mjs' : '.ts';
+    if (explicitOutput)
+        return path.resolve(explicitOutput);
+    const keveDir = (0, config_1.findKeveDir)();
+    const taskDir = (0, config_1.resolveTaskDir)(keveDir);
+    if (taskDir)
+        return path.join(taskDir, `keve-test.config${ext}`);
+    if (keveDir) {
+        const branchDir = (0, config_1.getBranchDir)(keveDir);
+        if (branchDir)
+            return path.join(branchDir, `keve-test.config${ext}`);
+        return path.join(keveDir, `keve-test.config${ext}`);
+    }
+    return path.join(process.cwd(), 'keve_test_spec', `keve-test.config${ext}`);
+}
+function findExistingConfig(keveDir, taskDir) {
+    const searchPaths = [];
+    if (taskDir) {
+        searchPaths.push(path.join(taskDir, 'keve-test.config.mjs'));
+        searchPaths.push(path.join(taskDir, 'keve-test.config.ts'));
+    }
+    if (keveDir) {
+        searchPaths.push(path.join(keveDir, 'keve-test.config.mjs'));
+        searchPaths.push(path.join(keveDir, 'keve-test.config.ts'));
+    }
+    searchPaths.push(path.join(process.cwd(), 'keve_test_spec', 'keve-test.config.mjs'));
+    searchPaths.push(path.join(process.cwd(), 'keve_test_spec', 'keve-test.config.ts'));
+    for (const p of searchPaths) {
+        if (require('fs').existsSync(p))
+            return p;
+    }
+    return null;
+}