@kkeve/suite 0.0.15 → 0.0.18

package/dist/core/judge/confidence.d.ts

@@ -0,0 +1,119 @@
+/**
+ * confidence — 用例结论与置信度的**引擎无关**判定
+ *
+ * 为什么单独成模块：Playwright 侧走 KeveReporter.onTestEnd，Cypress 侧没有
+ * in-process reporter，只能在 spec 里把结果经 bridge 送回 Node 后自行落盘。
+ * 两端若各写一份分类逻辑，报告必然漂移（同一失败在一边是 env、另一边是
+ * unknown）。这里把「附件解析 → Agent 结论 → 错误分类 → confidence 记录」
+ * 收敛成唯一实现，两端都只是喂数据。
+ *
+ * 约束：本模块只依赖类型与纯函数，Node 侧运行（读取 Buffer）。
+ */
+import { type RuntimeDiagnostics } from '../../page-agent/diagnostics.js';
+/** keveGoalResult attachment 的数据形态（Playwright / Cypress 完全一致） */
+export interface StepResultAttachment {
+    step: string;
+    expected: string;
+    precondition?: string;
+    order: number;
+    success: boolean;
+    conclusion?: 'pass' | 'fail' | 'blocked';
+    actions: Array<{
+        tool?: string;
+        role?: string;
+        name?: string;
+        url?: string;
+        text?: string;
+        reason?: string;
+        success?: boolean;
+        verdict?: string;
+        conclusion?: 'pass' | 'fail' | 'blocked';
+        result?: string;
+        error?: string;
+        toolOutput?: string;
+        evaluation?: string;
+        memory?: string;
+        nextGoal?: string;
+        screenshotPath?: string;
+    }>;
+    finalSnapshot?: string;
+    diagnosticHints?: string[];
+    /** 运行诊断：性能、网络、浏览器错误与质量信号 */
+    diagnostics?: RuntimeDiagnostics;
+    goalScreenshotBefore?: string;
+    goalScreenshotAfter?: string;
+    agentScreenshots?: string[];
+}
+/** 供分类使用的错误摘要（Error 实例跨引擎不可序列化，统一降级成 name+message） */
+export interface ConfidenceError {
+    message: string;
+    name?: string;
+}
+export interface AttachmentLike {
+    name?: string;
+    contentType?: string;
+    body?: any;
+    /** 附件在磁盘上的路径（与 Playwright 报告 attachments[].path 同形） */
+    path?: string;
+}
+export interface ClassifyInput {
+    /** 用例完整标题（`${sceneId}: ${description}`） */
+    title: string;
+    /** 执行状态：passed | failed | timedOut | skipped | unknown（Playwright 语义） */
+    status: string;
+    /** 失败摘要；无失败传 null */
+    error?: ConfidenceError | string | null;
+    /** keveGoalResult 附件（已解析或原始附件均可，二选一） */
+    steps: StepResultAttachment[];
+    /** 原始附件列表（用于诊断提示与 keveScreenshots 标签） */
+    attachments?: AttachmentLike[];
+    /** 是否跳过 AI 评估（由调用方强制指定，如 Cypress 侧无 AI 阶段） */
+    forceSkipAI?: boolean;
+}
+/** confidence-data.jsonl 的单行记录 */
+export interface ConfidenceRecord {
+    title: string;
+    data: string;
+    confidence: number;
+    thought: string;
+    errorCategory: ErrorCategory;
+    keveScreenshots?: string[];
+    steps: StepResultAttachment[];
+    diagnosticHint?: string;
+    /** 运行诊断（用例级聚合：各步骤求和/去重） */
+    diagnostics?: RuntimeDiagnostics;
+}
+export type ErrorCategory = 'script' | 'env' | 'assert' | 'visual' | 'text-mismatch' | 'incomplete' | 'pass' | 'unknown';
+/** confidence values by errorCategory — 给出有意义的分值而不是一律 0 */
+export declare const CONFIDENCE_MAP: Record<string, number>;
+/** 环境/基础设施错误特征（与 keve-decorators 的历史判定保持同源） */
+export declare const ENV_ERROR_PATTERNS: RegExp;
+/** 解码附件体：Playwright JSON reporter 会把 Buffer 序列化成 base64 字符串 */
+export declare function decodeAttachmentBody(body: any): string;
+/** 从附件列表解析全部 keveGoalResult → 统一步骤数组 */
+export declare function parseStepsFromAttachments(attachments: AttachmentLike[] | undefined): StepResultAttachment[];
+/** 从附件提取 Agent 结论（result + text）。串行执行下取最后一步 */
+export declare function extractAgentConclusion(steps: StepResultAttachment[]): {
+    result: 'pass' | 'fail' | 'blocked' | 'incomplete';
+    text: string;
+} | undefined;
+/** 由 keveGoalResult（优先）+ keveDiagnosticHint（兜底）拼诊断提示 */
+export declare function buildDiagnosticHint(attachments: AttachmentLike[] | undefined): string | undefined;
+/** keveAssert-* 附件 → 截图标签列表（报告只保留 label） */
+export declare function parseKeveScreenshotLabels(attachments: AttachmentLike[] | undefined): string[];
+/**
+ * 分类并生成 confidence 记录。
+ *
+ * 判定优先级：状态 → Agent 结论 → 错误特征兜底。两端共用同一条链路，
+ * 所以「同一个失败模式在 Playwright 与 Cypress 下得到同一个 errorCategory」。
+ */
+export declare function buildConfidenceRecord(input: ClassifyInput): {
+    record: ConfidenceRecord;
+    skipAI: boolean;
+    log: string;
+};
+/**
+ * 落盘前的记录清洗：剔除大字段（base64 截图与整页快照），
+ * 截图以文件路径形式存在于 goalScreenshotBefore/After 与 actions[].screenshotPath。
+ */
+export declare function sanitizeRecord(record: ConfidenceRecord): ConfidenceRecord;

package/dist/core/judge/confidence.js

@@ -0,0 +1,295 @@
+"use strict";
+/**
+ * confidence — 用例结论与置信度的**引擎无关**判定
+ *
+ * 为什么单独成模块：Playwright 侧走 KeveReporter.onTestEnd，Cypress 侧没有
+ * in-process reporter，只能在 spec 里把结果经 bridge 送回 Node 后自行落盘。
+ * 两端若各写一份分类逻辑，报告必然漂移（同一失败在一边是 env、另一边是
+ * unknown）。这里把「附件解析 → Agent 结论 → 错误分类 → confidence 记录」
+ * 收敛成唯一实现，两端都只是喂数据。
+ *
+ * 约束：本模块只依赖类型与纯函数，Node 侧运行（读取 Buffer）。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENV_ERROR_PATTERNS = exports.CONFIDENCE_MAP = void 0;
+exports.decodeAttachmentBody = decodeAttachmentBody;
+exports.parseStepsFromAttachments = parseStepsFromAttachments;
+exports.extractAgentConclusion = extractAgentConclusion;
+exports.buildDiagnosticHint = buildDiagnosticHint;
+exports.parseKeveScreenshotLabels = parseKeveScreenshotLabels;
+exports.buildConfidenceRecord = buildConfidenceRecord;
+exports.sanitizeRecord = sanitizeRecord;
+const diagnostics_js_1 = require("../../page-agent/diagnostics.js");
+// ─── 常量 ────────────────────────────────────────────────────────────
+/** confidence values by errorCategory — 给出有意义的分值而不是一律 0 */
+exports.CONFIDENCE_MAP = {
+    pass: 100, // 测试通过，确定性最高
+    script: 95, // 脚本代码错误，结果确定性高
+    visual: 80, // 视觉断言已评估，置信度较高
+    'text-mismatch': 70, // UI 文案格式不匹配（功能逻辑正确，措辞变了）
+    assert: 50, // 断言失败，需人工确认
+    incomplete: 0, // 执行被中断（超时/action 耗尽），无法得出结论
+    env: 0, // 环境问题，测试结果不可信
+    unknown: 0, // 未知异常，无参考价值
+};
+/** 环境/基础设施错误特征（与 keve-decorators 的历史判定保持同源） */
+exports.ENV_ERROR_PATTERNS = /timeout|timed out|locator.*not found|navigation.*intercepted|net::|ERR_|authenticate|redirect|ECONNREFUSED|socket hang up|Cannot navigate to invalid URL|Protocol error.*Page\.navigate/i;
+// ─── 附件解析 ────────────────────────────────────────────────────────
+/** 解码附件体：Playwright JSON reporter 会把 Buffer 序列化成 base64 字符串 */
+function decodeAttachmentBody(body) {
+    if (typeof body === 'string') {
+        // 先按 base64 解一次，仍是 JSON 就用解码结果；否则按原始字符串处理
+        try {
+            const decoded = Buffer.from(body, 'base64').toString('utf8');
+            JSON.parse(decoded);
+            return decoded;
+        }
+        catch {
+            return body;
+        }
+    }
+    if (Buffer.isBuffer(body))
+        return body.toString('utf8');
+    if (typeof body === 'object' && body !== null)
+        return JSON.stringify(body);
+    return String(body || '');
+}
+/** 从附件列表解析全部 keveGoalResult → 统一步骤数组 */
+function parseStepsFromAttachments(attachments) {
+    const results = [];
+    for (const att of attachments || []) {
+        if (att?.name !== 'keveGoalResult' || !att.body)
+            continue;
+        try {
+            results.push(JSON.parse(decodeAttachmentBody(att.body)));
+        }
+        catch { /* skip malformed attachment */ }
+    }
+    return results;
+}
+/** 从附件提取 Agent 结论（result + text）。串行执行下取最后一步 */
+function extractAgentConclusion(steps) {
+    if (steps.length === 0)
+        return undefined;
+    const lastStep = steps[steps.length - 1];
+    if (lastStep.conclusion) {
+        const doneAction = lastStep.actions?.find((a) => a.tool === 'done');
+        return { result: lastStep.conclusion, text: doneAction?.text || '' };
+    }
+    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 { result: 'incomplete', text: '执行被中断，Agent未完成目标' };
+}
+/** 由 keveGoalResult（优先）+ keveDiagnosticHint（兜底）拼诊断提示 */
+function buildDiagnosticHint(attachments) {
+    const allHints = [];
+    for (const gr of parseStepsFromAttachments(attachments)) {
+        if (gr.success)
+            continue;
+        if (gr.diagnosticHints?.length)
+            allHints.push(...gr.diagnosticHints);
+    }
+    if (allHints.length)
+        return allHints.join('；');
+    const hint = (attachments || []).find((a) => a.name === 'keveDiagnosticHint' && a.body);
+    if (!hint)
+        return undefined;
+    try {
+        const data = JSON.parse(decodeAttachmentBody(hint.body));
+        return data.hints?.join('；') || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** keveAssert-* 附件 → 截图标签列表（报告只保留 label） */
+function parseKeveScreenshotLabels(attachments) {
+    const labels = [];
+    for (const att of attachments || []) {
+        if (att?.name?.startsWith('keveAssert-') && att.contentType === 'application/json' && att.body) {
+            labels.push(att.name.replace('keveAssert-', ''));
+        }
+    }
+    return labels;
+}
+// ─── 分类主逻辑 ──────────────────────────────────────────────────────
+function normalizeError(error) {
+    if (!error)
+        return undefined;
+    if (typeof error === 'string')
+        return { message: error };
+    return { message: String(error.message || ''), name: error.name };
+}
+/**
+ * 分类并生成 confidence 记录。
+ *
+ * 判定优先级：状态 → Agent 结论 → 错误特征兜底。两端共用同一条链路，
+ * 所以「同一个失败模式在 Playwright 与 Cypress 下得到同一个 errorCategory」。
+ */
+function buildConfidenceRecord(input) {
+    const attachments = input.attachments || [];
+    const steps = input.steps?.length ? input.steps : parseStepsFromAttachments(attachments);
+    const agentConclusion = extractAgentConclusion(steps);
+    const diagnosticHint = buildDiagnosticHint(attachments);
+    const diagnostics = (0, diagnostics_js_1.mergeRuntimeDiagnostics)(steps.map((s) => s.diagnostics));
+    let effectiveCategory = 'unknown';
+    let skipAI = false;
+    let classifiedMessage = '';
+    if (input.status === 'skipped') {
+        const record = {
+            title: input.title,
+            data: '跳过',
+            confidence: 0,
+            thought: '用例被跳过（非自动执行）',
+            errorCategory: 'unknown',
+            steps,
+            diagnosticHint: undefined,
+            diagnostics,
+        };
+        return { record, skipAI: true, log: 'SKIPPED' };
+    }
+    if (input.status === 'passed') {
+        effectiveCategory = 'pass';
+    }
+    else if (agentConclusion) {
+        classifiedMessage = agentConclusion.text.substring(0, 500);
+        if (agentConclusion.result === 'pass') {
+            // Agent 说通过但用例仍失败 → 脚本问题
+            effectiveCategory = 'pass';
+            skipAI = true;
+        }
+        else if (agentConclusion.result === 'blocked') {
+            effectiveCategory = 'env';
+            skipAI = true;
+        }
+        else if (agentConclusion.result === 'incomplete') {
+            effectiveCategory = 'incomplete';
+            skipAI = true;
+        }
+        else {
+            if (diagnosticHint && (diagnosticHint.includes('实际显示') || diagnosticHint.includes('页面实际') || diagnosticHint.includes('而非预期'))) {
+                effectiveCategory = 'text-mismatch';
+                skipAI = false;
+            }
+            else {
+                effectiveCategory = 'assert';
+                skipAI = false;
+            }
+        }
+    }
+    else {
+        const err = normalizeError(input.error);
+        if (err) {
+            const rawError = err.message || '';
+            classifiedMessage = rawError.substring(0, 500);
+            const errName = err.name || '';
+            if (errName === 'TypeError' || errName === 'ReferenceError' || errName === 'SyntaxError') {
+                effectiveCategory = 'script';
+                skipAI = true;
+            }
+            else if (rawError.includes('视觉断言失败')) {
+                effectiveCategory = 'visual';
+                skipAI = true;
+            }
+            else if (rawError.includes('expect(') || errName === 'AssertionError') {
+                effectiveCategory = 'assert';
+                skipAI = false;
+            }
+            else if (exports.ENV_ERROR_PATTERNS.test(rawError.substring(0, 300))) {
+                effectiveCategory = 'env';
+                skipAI = true;
+            }
+            else if (rawError.includes('Re-Act loop did not achieve') || rawError.includes('Expected not achieved after agent explore')) {
+                effectiveCategory = 'incomplete';
+                skipAI = true;
+            }
+            else if (rawError.includes('Expected not achieved')) {
+                if (diagnosticHint && (diagnosticHint.includes('实际显示') || diagnosticHint.includes('页面实际'))) {
+                    effectiveCategory = 'text-mismatch';
+                    skipAI = false;
+                }
+                else {
+                    effectiveCategory = 'incomplete';
+                    skipAI = true;
+                }
+            }
+            else {
+                effectiveCategory = 'unknown';
+                skipAI = true;
+            }
+        }
+    }
+    const keveScreenshots = parseKeveScreenshotLabels(attachments);
+    if (skipAI) {
+        const thought = effectiveCategory === 'script'
+            ? `脚本本身存在代码错误(${classifiedMessage})，测试结果无效`
+            : effectiveCategory === 'env'
+                ? `环境/基础设施异常(${classifiedMessage})，非应用功能问题`
+                : effectiveCategory === 'visual'
+                    ? `视觉断言失败(${classifiedMessage})，已由keveAssert评估`
+                    : effectiveCategory === 'unknown'
+                        ? `无法分类的异常(${classifiedMessage})，跳过AI评估`
+                        : effectiveCategory === 'pass'
+                            ? `Agent判定通过但fn脚本执行失败(${classifiedMessage})，脚本需修复`
+                            : effectiveCategory === 'incomplete'
+                                ? `Agent执行超过探索上限(${classifiedMessage})，未完成目标，需要人工确认`
+                                : `无法分类的异常(${classifiedMessage})`;
+        // AI 评估列：assert/text-mismatch → 不通过；其余无法得出结论 → 阻塞
+        const aiData = (effectiveCategory === 'assert' || effectiveCategory === 'text-mismatch') ? '不通过' : '阻塞';
+        return {
+            record: {
+                title: input.title,
+                data: aiData,
+                confidence: exports.CONFIDENCE_MAP[effectiveCategory] ?? 0,
+                thought,
+                errorCategory: effectiveCategory,
+                ...(keveScreenshots.length > 0 ? { keveScreenshots } : {}),
+                steps,
+                diagnosticHint,
+                diagnostics,
+            },
+            skipAI: true,
+            log: `SHORT-CIRCUIT skipAI (category=${effectiveCategory})`,
+        };
+    }
+    return {
+        record: {
+            title: input.title,
+            data: input.status === 'passed' ? '通过' : '不通过',
+            confidence: exports.CONFIDENCE_MAP[effectiveCategory] ?? 0,
+            thought: input.status === 'passed' && agentConclusion?.result === 'pass' ? agentConclusion.text : '',
+            errorCategory: effectiveCategory,
+            ...(keveScreenshots.length > 0 ? { keveScreenshots } : {}),
+            steps,
+            diagnosticHint,
+            diagnostics,
+        },
+        skipAI: false,
+        log: `${input.status} (category=${effectiveCategory})`,
+    };
+}
+/**
+ * 落盘前的记录清洗：剔除大字段（base64 截图与整页快照），
+ * 截图以文件路径形式存在于 goalScreenshotBefore/After 与 actions[].screenshotPath。
+ */
+function sanitizeRecord(record) {
+    if (!record.steps)
+        return record;
+    record.steps = record.steps.map((step) => {
+        const { screenshotBase64, finalSnapshot, ...stepRest } = step;
+        if (stepRest.actions) {
+            stepRest.actions = stepRest.actions.map((a) => {
+                const { snapshotPreview, ...actionRest } = a;
+                return actionRest;
+            });
+        }
+        return stepRest;
+    });
+    return record;
+}

package/dist/core/judge/goal-heuristics.d.ts

@@ -0,0 +1,32 @@
+/**
+ * goal-heuristics — keveGoal 的错误归因判定（引擎无关）
+ *
+ * 为什么单独成模块：Playwright 的 keveGoal（core/keve-test.ts 的 fixture）与
+ * Cypress 的 keveGoal（engine-cypress/keveGoal.ts）必须对同一段错误字符串给出
+ * 完全相同的结论 —— 否则「环境问题」在一端是 BLOCKED、另一端是 FAIL，
+ * 报告与置信度都会漂移。
+ *
+ * 约束：纯函数 + 零依赖（Cypress 浏览器 bundle 会直接打包本模块）。
+ */
+/**
+ * 判断错误是否属于「环境阻塞」：这类错误 Agent Re-Act 无法修复，
+ * 应直接判 BLOCKED 而不是烧 token 探索。
+ *
+ * 覆盖：空 URL、连接拒绝、导航超时、IDC 网段限制、SSO 跳转、页面/浏览器已关闭。
+ * 注意：定位器超时**不算**（那是脚本选择器问题，应交给 Agent 自愈）。
+ */
+export declare function isEnvironmentBlockedError(err: any): boolean;
+/**
+ * 判断错误是否为「确定性断言失败」（Expected/Received 形态）。
+ *
+ * 这类失败是事实而非判断：即使 Agent 认为「通过」，也必须由确定性结果覆盖。
+ * 同时用于在错误文案里保留精确的 expected/received 信息。
+ */
+export declare function isAssertionFailure(error: string): boolean;
+/**
+ * 推导 done action 的三态结论（pass/fail/blocked）。
+ *
+ * 4 级回退：step 级 conclusion → action.verdict → action.result → action.success / 文本关键词。
+ * 文本匹配必须先判 fail/blocked 再判 pass，否则「不通过」会被「通过」命中。
+ */
+export declare function deriveActionConclusion(stepConclusion: string | undefined, action: any): 'pass' | 'fail' | 'blocked' | undefined;

package/dist/core/judge/goal-heuristics.js

@@ -0,0 +1,128 @@
+"use strict";
+/**
+ * goal-heuristics — keveGoal 的错误归因判定（引擎无关）
+ *
+ * 为什么单独成模块：Playwright 的 keveGoal（core/keve-test.ts 的 fixture）与
+ * Cypress 的 keveGoal（engine-cypress/keveGoal.ts）必须对同一段错误字符串给出
+ * 完全相同的结论 —— 否则「环境问题」在一端是 BLOCKED、另一端是 FAIL，
+ * 报告与置信度都会漂移。
+ *
+ * 约束：纯函数 + 零依赖（Cypress 浏览器 bundle 会直接打包本模块）。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEnvironmentBlockedError = isEnvironmentBlockedError;
+exports.isAssertionFailure = isAssertionFailure;
+exports.deriveActionConclusion = deriveActionConclusion;
+/**
+ * 判断错误是否属于「环境阻塞」：这类错误 Agent Re-Act 无法修复，
+ * 应直接判 BLOCKED 而不是烧 token 探索。
+ *
+ * 覆盖：空 URL、连接拒绝、导航超时、IDC 网段限制、SSO 跳转、页面/浏览器已关闭。
+ * 注意：定位器超时**不算**（那是脚本选择器问题，应交给 Agent 自愈）。
+ */
+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;
+    }
+    // 参数为 undefined（如 PAGE_* 环境变量缺失）
+    if ((msg.includes('expected string') || msg.includes('expected a string'))
+        && (msg.includes('got undefined') || msg.includes('got null') || msg.includes('received undefined'))) {
+        return true;
+    }
+    // 连接被拒 / 网络不可达
+    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;
+    }
+    // 导航超时（页面不可达）
+    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')
+        || msg.includes('[cypress-engine] 导航超时') || msg.includes('[cypress-engine] 刷新超时')) {
+        return true;
+    }
+    // IDC 网段限制
+    if (msg.includes('unable to access on the idc network segment')
+        || msg.includes('idc network segment') || msg.includes('40314')) {
+        return true;
+    }
+    // SSO / 登录跳转（非应用自身问题）
+    if (msg.includes('sso redirect') || msg.includes('login redirect detected')
+        || msg.includes('err_too_many_redirects')) {
+        return true;
+    }
+    // 页面/上下文/浏览器已关闭 —— Agent 无法探索
+    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') || msg.includes('未找到 aut frame')) {
+        return true;
+    }
+    return false;
+}
+/**
+ * 判断错误是否为「确定性断言失败」（Expected/Received 形态）。
+ *
+ * 这类失败是事实而非判断：即使 Agent 认为「通过」，也必须由确定性结果覆盖。
+ * 同时用于在错误文案里保留精确的 expected/received 信息。
+ */
+function isAssertionFailure(error) {
+    const msg = (error || '').toLowerCase();
+    // 排除 API 参数类型错误（不是值断言）
+    if (msg.includes('expected string') || msg.includes('expected a string')
+        || msg.includes('expected number') || msg.includes('expected boolean')) {
+        if (msg.includes('got undefined') || msg.includes('got null')
+            || msg.includes('received undefined') || msg.includes('received null')) {
+            return false;
+        }
+    }
+    // Jest/Vitest/Playwright 断言：Expected: X, Received: Y
+    if (msg.includes('expected') && msg.includes('received'))
+        return true;
+    if (msg.includes('assertionerror') || msg.includes('assertion failed')
+        || msg.includes('assertion error'))
+        return true;
+    // 引擎侧断言文案（CypressEngine.expect* / PlaywrightEngine.expect*）
+    if (msg.includes('断言失败'))
+        return true;
+    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;
+    if (msg.includes('expected ') && (msg.includes(' but ') || msg.includes(' got ') || msg.includes(' received ')))
+        return true;
+    return false;
+}
+/**
+ * 推导 done action 的三态结论（pass/fail/blocked）。
+ *
+ * 4 级回退：step 级 conclusion → action.verdict → action.result → action.success / 文本关键词。
+ * 文本匹配必须先判 fail/blocked 再判 pass，否则「不通过」会被「通过」命中。
+ */
+function deriveActionConclusion(stepConclusion, action) {
+    if (action?.tool !== 'done')
+        return undefined;
+    if (stepConclusion)
+        return stepConclusion;
+    const verdict = action?.verdict;
+    if (verdict === 'pass' || verdict === 'fail' || verdict === 'blocked')
+        return verdict;
+    const raw = action?.result;
+    if (raw === 'pass' || raw === 'fail' || raw === 'blocked')
+        return raw;
+    if (typeof action?.success === 'boolean')
+        return action.success ? 'pass' : 'fail';
+    const tv = String(action?.text || '').trim().toLowerCase();
+    if (tv.includes('fail') || tv.includes('failure')
+        || tv.includes('失败') || tv.includes('未通过') || tv.includes('不通过'))
+        return 'fail';
+    if (tv.includes('blocked') || tv.includes('阻塞') || tv.includes('阻止'))
+        return 'blocked';
+    if (tv.includes('pass') || tv.includes('success') || tv.includes('ok')
+        || tv.includes('完成') || tv.includes('成功') || tv.includes('通过') || tv.includes('验证通过'))
+        return 'pass';
+    return undefined;
+}

package/dist/core/judge/pngCodec.d.ts

@@ -0,0 +1,23 @@
+/**
+ * pngCodec — 纯 Node PNG 编解码（零依赖，zlib 内置）
+ *
+ * 为什么不用 pngjs/pixelmatch：@kkeve/suite 依赖树里没有这两个包，
+ * 执行环境（keve-wiki / 调度节点）也不保证能现场安装 —— 而引擎侧截图对比
+ * 是核心链路，不能带可选依赖。Playwright 截图恒为 8-bit、非交错、
+ * colorType 2(RGB)/6(RGBA)，覆盖这两类 + 灰度(0/4)即可覆盖全部引擎产物。
+ *
+ * 支持范围（超出范围抛错，不静默出错误结果）：
+ *   - bitDepth: 8
+ *   - colorType: 0(灰度) / 2(RGB) / 4(灰+A) / 6(RGBA)
+ *   - interlace: 0（Progressive PNG 抛错）
+ */
+export interface RawImage {
+    width: number;
+    height: number;
+    /** RGBA，4 通道，每像素 4 字节 */
+    data: Uint8Array;
+}
+/** 解码 PNG → RGBA。仅支持 8-bit / colorType 0,2,4,6 / 非交错 */
+export declare function decodePng(buf: Buffer): RawImage;
+/** RGBA → PNG（colorType 6，filter 0）。data 长度必须为 w*h*4 */
+export declare function encodePng(width: number, height: number, data: Uint8Array): Buffer;