@gracker/smartperfetto 1.0.13

package/dist/services/skillEngine/skillExecutor.js

@@ -0,0 +1,4129 @@
+"use strict";
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (C) 2024-2026 Gracker (Chris)
+// This file is part of SmartPerfetto. See LICENSE for details.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillExecutor = void 0;
+exports.normalizeLayer = normalizeLayer;
+exports.extractFindings = extractFindings;
+exports.extractSuggestions = extractSuggestions;
+exports.createSkillExecutor = createSkillExecutor;
+const skillValidator_1 = require("./skillValidator");
+const logger_1 = __importDefault(require("../../utils/logger"));
+const llmJson_1 = require("../../utils/llmJson");
+const llmPrivacy_1 = require("../../utils/llmPrivacy");
+const pipelineDocService_1 = require("../pipelineDocService");
+const pipelineSkillLoader_1 = require("../pipelineSkillLoader");
+const teaching_config_1 = require("../../config/teaching.config");
+const teaching_types_1 = require("../../types/teaching.types");
+const dataContract_1 = require("../../types/dataContract");
+const displayContractValidator_1 = require("./displayContractValidator");
+const identityGate_1 = require("../processIdentity/identityGate");
+/**
+ * 将 YAML 中的 layer 值规范化为语义名称
+ */
+function normalizeLayer(layer) {
+    if (!layer)
+        return undefined;
+    // 只接受语义名称
+    if (['overview', 'list', 'session', 'deep', 'diagnosis'].includes(layer)) {
+        return layer;
+    }
+    return undefined;
+}
+// =============================================================================
+// 表达式求值器
+// =============================================================================
+class ExpressionEvaluator {
+    static warnConditionOnce(reason, condition, extra) {
+        const key = `${reason}::${condition}`;
+        if (this.warnedConditionMessages.has(key))
+            return;
+        this.warnedConditionMessages.add(key);
+        logger_1.default.warn('ExpressionEvaluator', `${reason}: ${condition}${extra ? ` (${extra})` : ''}`);
+    }
+    /**
+     * 在上下文中求值表达式
+     * 支持：${variable}、${step.field}、比较运算符等
+     */
+    static evaluate(expression, context) {
+        const parsePathWithDefault = (raw) => {
+            const m = raw.trim().match(/^([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*|\[[0-9]+\])*)\|([^|].*)$/);
+            if (!m)
+                return null;
+            return { actualPath: m[1].trim(), defaultValue: m[2].trim() };
+        };
+        // 检查是否是完整的 ${...} 表达式（整个字符串被包裹）
+        const fullExprMatch = expression.match(/^\$\{(.+)\}$/s);
+        // 如果内部还包含 ${...}，说明这是一个模板串（如 "${a} + ${b}"），不要当成单个 JS 表达式执行
+        if (fullExprMatch && !fullExprMatch[1].includes('${')) {
+            const innerExpr = fullExprMatch[1].trim();
+            // Support ${varName|defaultValue} syntax for full expressions
+            const defaultSyntax = parsePathWithDefault(innerExpr);
+            if (defaultSyntax) {
+                const value = this.resolvePath(defaultSyntax.actualPath, context);
+                if (value !== undefined && value !== null)
+                    return value;
+                const defaultPart = defaultSyntax.defaultValue;
+                // Parse default: try number, boolean, then string
+                if (/^\d+(\.\d+)?$/.test(defaultPart))
+                    return parseFloat(defaultPart);
+                if (defaultPart === 'true')
+                    return true;
+                if (defaultPart === 'false')
+                    return false;
+                return defaultPart;
+            }
+            // 这是一个 JavaScript 表达式，需要完整求值
+            return this.evaluateJsExpression(innerExpr, context);
+        }
+        // 否则，做变量替换（支持嵌入的 JavaScript 表达式）
+        let result = expression;
+        // 替换 ${xxx} 格式的变量
+        // 简单路径走 resolvePath；复杂表达式走 JS 表达式求值（例如: a * 16.7, foo?.bar, arr.find(...)）
+        const isSimplePath = (path) => {
+            const p = path.trim();
+            // 仅允许：标识符 + ".prop" + "[0]" 组合（不支持 ?. / 函数调用 / 算术运算等）
+            return /^[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*|\[[0-9]+\])*$/.test(p);
+        };
+        result = result.replace(/\$\{([^}]+)\}/g, (match, path) => {
+            const rawPath = String(path ?? '').trim();
+            // Support ${varName|defaultValue} syntax
+            const defaultSyntax = parsePathWithDefault(rawPath);
+            const actualPath = defaultSyntax?.actualPath ?? rawPath;
+            const defaultValue = defaultSyntax?.defaultValue;
+            // 复杂表达式：使用完整的 JS 表达式求值
+            if (!isSimplePath(actualPath)) {
+                try {
+                    const value = this.evaluateJsExpression(actualPath, context);
+                    if (value === undefined || value === null) {
+                        return defaultValue !== undefined ? defaultValue : '';
+                    }
+                    if (typeof value === 'object')
+                        return JSON.stringify(value);
+                    return String(value);
+                }
+                catch (e) {
+                    logger_1.default.debug('ExpressionEvaluator', `Failed to evaluate embedded JS: ${actualPath}`);
+                    return defaultValue !== undefined ? defaultValue : '';
+                }
+            }
+            // 简单路径：使用 resolvePath
+            const value = this.resolvePath(actualPath, context);
+            if (value === undefined || value === null) {
+                return defaultValue !== undefined ? defaultValue : '';
+            }
+            if (typeof value === 'object')
+                return JSON.stringify(value);
+            return String(value);
+        });
+        // 如果是简单的比较表达式，尝试求值
+        if (/^[\d\.\s\+\-\*\/\>\<\=\!\&\|]+$/.test(result)) {
+            try {
+                // 安全地执行简单数学/比较表达式
+                return new Function(`return ${result}`)();
+            }
+            catch {
+                return result;
+            }
+        }
+        return result;
+    }
+    /**
+     * 评估 JavaScript 表达式
+     * 例如: performance_summary.data[0]?.app_jank_rate > 10
+     */
+    static evaluateJsExpression(expr, context, options) {
+        try {
+            // 从表达式中提取根变量名
+            const rootVarNames = this.extractRootVariables(expr);
+            // 构建作用域对象
+            const scope = {};
+            for (const varName of rootVarNames) {
+                // 从步骤结果中获取
+                if (context.results[varName]) {
+                    scope[varName] = this.wrapAsDataScope(context.results[varName].data);
+                }
+                // 从变量中获取
+                else if (context.variables[varName] !== undefined) {
+                    scope[varName] = this.wrapAsDataScope(context.variables[varName]);
+                }
+                // 从参数中获取
+                else if (context.params[varName] !== undefined) {
+                    scope[varName] = context.params[varName];
+                }
+                // 从继承上下文中获取
+                else if (context.inherited[varName] !== undefined) {
+                    scope[varName] = context.inherited[varName];
+                }
+                // 当前迭代项
+                else if (varName === 'item' && context.currentItem) {
+                    scope[varName] = context.currentItem;
+                }
+                // 未找到时也显式注入 undefined，避免 ReferenceError（例如 expr: "package" 或 "frame_ts"）
+                else {
+                    scope[varName] = undefined;
+                }
+            }
+            // Debug log removed for cleaner output
+            // 构建并执行函数
+            const varNames = Object.keys(scope);
+            const varValues = Object.values(scope);
+            if (varNames.length === 0) {
+                // 没有变量，直接求值（纯表达式如 true, false, 数字比较）
+                return new Function(`return ${expr}`)();
+            }
+            const fn = new Function(...varNames, `return ${expr}`);
+            const result = fn(...varValues);
+            return result;
+        }
+        catch (e) {
+            if (!options?.suppressErrorLog) {
+                logger_1.default.debug('ExpressionEvaluator', `JS expression failed: ${expr} (${e.message})`);
+            }
+            return undefined;
+        }
+    }
+    /**
+     * 从表达式中提取根变量名
+     * "performance_summary.data[0]?.app_jank_rate > 10" => ["performance_summary"]
+     * "jank_stats.data.find(j => j.jank_type)" => ["jank_stats"]
+     */
+    static extractRootVariables(expr) {
+        const varNames = new Set();
+        // 匹配标识符开头的词（不是关键字）
+        const identifierRegex = /\b([a-zA-Z_][a-zA-Z0-9_]*)\b/g;
+        const jsKeywords = new Set([
+            'true', 'false', 'null', 'undefined', 'if', 'else', 'return',
+            'function', 'var', 'let', 'const', 'new', 'this', 'typeof',
+            'instanceof', 'in', 'of', 'for', 'while', 'do', 'break', 'continue',
+            'switch', 'case', 'default', 'try', 'catch', 'finally', 'throw',
+            'async', 'await', 'class', 'extends', 'super', 'import', 'export',
+            'NaN', 'Infinity', 'Math', 'JSON', 'Array', 'Object', 'String',
+            'Number', 'Boolean', 'Date', 'RegExp', 'Error', 'Map', 'Set',
+        ]);
+        let match;
+        while ((match = identifierRegex.exec(expr)) !== null) {
+            const name = match[1];
+            // 跳过 JavaScript 关键字和内置对象
+            if (!jsKeywords.has(name)) {
+                // 检查是否是表达式开头或者在运算符后面（说明是根变量）
+                const beforeMatch = expr.substring(0, match.index);
+                const lastChar = beforeMatch.trim().slice(-1);
+                // 如果之前没有 . 则是根变量
+                if (lastChar !== '.') {
+                    varNames.add(name);
+                }
+            }
+        }
+        return Array.from(varNames);
+    }
+    /**
+     * Unwrap SkillExecutionResult-like objects from referenced skills.
+     * save_as on `skill:` steps stores nested result objects, while most YAML
+     * expressions expect plain row arrays at `.data`.
+     */
+    static unwrapSkillResultData(value) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            return value;
+        }
+        const maybeSkillResult = value;
+        // Full SkillExecutionResult from a referenced skill step.
+        // Prefer explicit `data` if present; otherwise fallback to raw step outputs.
+        if (Object.prototype.hasOwnProperty.call(maybeSkillResult, 'rawResults')) {
+            if (Object.prototype.hasOwnProperty.call(maybeSkillResult, 'data')) {
+                return maybeSkillResult.data;
+            }
+            const raw = maybeSkillResult.rawResults;
+            if (raw && typeof raw === 'object') {
+                const rootStepData = raw?.root?.data;
+                if (rootStepData !== undefined) {
+                    return rootStepData;
+                }
+                for (const step of Object.values(raw)) {
+                    if (step && typeof step === 'object' && Object.prototype.hasOwnProperty.call(step, 'data')) {
+                        return step.data;
+                    }
+                }
+            }
+        }
+        // StepResult-like object.
+        if (Object.prototype.hasOwnProperty.call(maybeSkillResult, 'success') &&
+            Object.prototype.hasOwnProperty.call(maybeSkillResult, 'data')) {
+            return maybeSkillResult.data;
+        }
+        return value;
+    }
+    /**
+     * Wrap values for `.data[...]` access pattern used by skill conditions.
+     */
+    static wrapAsDataScope(value) {
+        return { data: this.unwrapSkillResultData(value) };
+    }
+    /**
+     * 解析路径引用，支持深层嵌套和数组索引
+     * 例如: "step1.data[0].field" 或 "performance_summary.data[0].app_jank_rate"
+     */
+    static resolvePath(path, context) {
+        // 解析路径为 token 数组，支持 . 分隔和 [n] 数组索引
+        const tokens = this.parsePath(path);
+        if (tokens.length === 0)
+            return undefined;
+        const rootKey = tokens[0];
+        // 获取根值
+        let value;
+        // 尝试从不同来源解析根值
+        // 1. 当前迭代项
+        if (rootKey === 'item' && context.currentItem) {
+            value = context.currentItem;
+        }
+        // 2. 参数
+        else if (context.params[rootKey] !== undefined) {
+            value = context.params[rootKey];
+        }
+        // 3. 继承的上下文
+        else if (context.inherited[rootKey] !== undefined) {
+            value = context.inherited[rootKey];
+        }
+        // 4. 变量（save_as 保存的）- 也需要包装以支持 .data[0].field 访问
+        else if (context.variables[rootKey] !== undefined) {
+            // 如果路径包含 .data，需要包装；否则直接返回
+            const nextToken = tokens[1];
+            if (nextToken === 'data') {
+                value = this.wrapAsDataScope(context.variables[rootKey]);
+            }
+            else {
+                // 直接访问数组元素，如 ${main_slices[0].name}
+                value = context.variables[rootKey];
+            }
+        }
+        // 5. 步骤结果 - 返回包装对象以支持 .data[0].field 访问
+        else if (context.results[rootKey]) {
+            // 返回包含 data 属性的对象，这样 ${main_slices.data[0].name} 才能正确解析
+            value = this.wrapAsDataScope(context.results[rootKey].data);
+        }
+        else {
+            return undefined;
+        }
+        // 遍历剩余 token 解析深层路径
+        for (let i = 1; i < tokens.length; i++) {
+            if (value == null)
+                return undefined;
+            const token = tokens[i];
+            // 处理数组索引 (纯数字)
+            if (/^\d+$/.test(token)) {
+                const index = parseInt(token, 10);
+                if (!Array.isArray(value))
+                    return undefined;
+                value = value[index];
+            }
+            else {
+                // 处理对象属性
+                value = value[token];
+            }
+        }
+        return value;
+    }
+    /**
+     * 解析路径字符串为 token 数组
+     * "step.data[0].field" => ["step", "data", "0", "field"]
+     */
+    static parsePath(path) {
+        const tokens = [];
+        let current = '';
+        for (let i = 0; i < path.length; i++) {
+            const char = path[i];
+            if (char === '.') {
+                if (current) {
+                    tokens.push(current);
+                    current = '';
+                }
+            }
+            else if (char === '[') {
+                if (current) {
+                    tokens.push(current);
+                    current = '';
+                }
+            }
+            else if (char === ']') {
+                if (current) {
+                    tokens.push(current);
+                    current = '';
+                }
+            }
+            else {
+                current += char;
+            }
+        }
+        if (current) {
+            tokens.push(current);
+        }
+        return tokens;
+    }
+    /**
+     * 评估条件表达式，返回 boolean
+     * 条件表达式始终作为 JavaScript 表达式求值（不需要 ${} 包裹）
+     * 例如: environment.data[0]?.frame_data_status === 'available'
+     */
+    static evaluateCondition(condition, context) {
+        try {
+            // 允许 condition 中混用 ${...} 模板（如 "${vsync_missed} >= 3" 或 "cpu.data[0] > ${frame_dur} ...")
+            // 先做模板替换/简单表达式求值，再作为 JS 表达式执行。
+            let prepared = condition;
+            if (typeof condition === 'string' && condition.includes('${')) {
+                prepared = this.evaluate(condition, context);
+            }
+            // evaluate 可能直接返回 boolean/number（例如 "3 >= 1"）
+            if (prepared === undefined || prepared === null) {
+                return false;
+            }
+            if (typeof prepared === 'boolean') {
+                return prepared;
+            }
+            if (typeof prepared === 'number') {
+                return prepared !== 0;
+            }
+            if (typeof prepared !== 'string') {
+                return Boolean(prepared);
+            }
+            const expr = prepared.trim();
+            if (!expr)
+                return false;
+            if (expr.includes('${')) {
+                // 未替换完的模板通常意味着上游数据缺失，不作为告警噪声输出。
+                logger_1.default.debug('ExpressionEvaluator', `Condition still contains template placeholders: ${expr}`);
+                return false;
+            }
+            // 条件表达式作为 JavaScript 表达式求值
+            const result = this.evaluateJsExpression(expr, context, { suppressErrorLog: true });
+            // 如果求值失败（返回 undefined），默认为 false
+            if (result === undefined) {
+                return false;
+            }
+            return Boolean(result);
+        }
+        catch (e) {
+            this.warnConditionOnce('Condition evaluation failed', condition, e.message);
+            return false;
+        }
+    }
+}
+ExpressionEvaluator.warnedConditionMessages = new Set();
+// =============================================================================
+// SQL 变量替换
+// =============================================================================
+function substituteVariables(sql, context) {
+    let result = sql;
+    // 判断 offset 位置是否处于 SQL 单引号字符串常量内部（用于决定缺省值是 '' 还是 NULL）
+    // 注：这里只做轻量扫描，足够覆盖 skill SQL 模板中常见的 '${package}*' / '%${name}%' 等模式。
+    const isInsideSingleQuotes = (s, offset) => {
+        let inSingle = false;
+        for (let i = 0; i < offset; i++) {
+            const ch = s[i];
+            if (ch !== '\'')
+                continue;
+            // SQL 中单引号转义使用 ''（两个单引号）。
+            if (inSingle && s[i + 1] === '\'') {
+                i++; // skip escaped quote
+                continue;
+            }
+            inSingle = !inSingle;
+        }
+        return inSingle;
+    };
+    // 替换所有 ${xxx} 格式的变量（支持 ${varName|defaultValue} 语法）
+    result = result.replace(/\$\{([^}]+)\}/g, (match, path, offset, full) => {
+        const rawPath = String(path ?? '').trim();
+        const insideQuotes = typeof offset === 'number' && typeof full === 'string'
+            ? isInsideSingleQuotes(full, offset)
+            : false;
+        // Support ${varName|defaultValue} syntax
+        const pipeIndex = rawPath.indexOf('|');
+        const actualPath = pipeIndex >= 0 ? rawPath.substring(0, pipeIndex).trim() : rawPath;
+        const explicitDefault = pipeIndex >= 0 ? rawPath.substring(pipeIndex + 1).trim() : undefined;
+        const value = ExpressionEvaluator.resolvePath(actualPath, context);
+        // 缺省值优先级：
+        // 1. 显式 |default 值
+        // 2. 字符串常量内部：用 ''
+        // 3. 其它位置：用 NULL
+        if (value === undefined || value === null) {
+            if (explicitDefault !== undefined)
+                return explicitDefault;
+            if (insideQuotes)
+                return '';
+            return 'NULL';
+        }
+        // 如果值被插入到单引号字符串中，必须转义单引号，避免 SQL 解析错误
+        if (insideQuotes && typeof value === 'string') {
+            return value.replace(/'/g, '\'\'');
+        }
+        // save_as 存储的是行数组 [{col: val, ...}, ...]。
+        // 当下游 SQL 用 SELECT * FROM ${variable} 引用时，需要转为 inline CTE。
+        if (Array.isArray(value) && value.length > 0 && typeof value[0] === 'object') {
+            return arrayToInlineCte(value);
+        }
+        return String(value);
+    });
+    return result;
+}
+/**
+ * Convert a save_as row array to an inline SQLite CTE.
+ * [{a: 1, b: 'x'}, {a: 2, b: 'y'}]  →  (SELECT 1 as a, 'x' as b UNION ALL SELECT 2, 'y')
+ */
+function arrayToInlineCte(rows) {
+    if (rows.length === 0)
+        return '(SELECT NULL LIMIT 0)';
+    const columns = Object.keys(rows[0]);
+    const selects = rows.map((row, i) => {
+        const values = columns.map((col) => {
+            const v = row[col];
+            if (v === null || v === undefined)
+                return 'NULL';
+            if (typeof v === 'number' || typeof v === 'bigint')
+                return String(v);
+            // String values: escape single quotes for SQL
+            return `'${String(v).replace(/'/g, "''")}'`;
+        });
+        // First row includes column aliases; subsequent rows omit them
+        if (i === 0) {
+            return `SELECT ${values.map((v, j) => `${v} as ${columns[j]}`).join(', ')}`;
+        }
+        return `SELECT ${values.join(', ')}`;
+    });
+    return `(${selects.join(' UNION ALL ')})`;
+}
+// =============================================================================
+// Display 配置处理（支持模板变量替换）
+// =============================================================================
+/**
+ * 处理 display 配置，对字符串值进行模板变量替换
+ * 支持 ${variable} 格式的变量替换
+ */
+function processDisplayConfig(display, context) {
+    const processed = { ...display };
+    // 处理 title 字段（字符串类型）
+    if (processed.title && typeof processed.title === 'string') {
+        processed.title = substituteVariables(processed.title, context);
+    }
+    // 如果未来需要处理其他字符串字段（如 description），可以在这里添加
+    // if (processed.description && typeof processed.description === 'string') {
+    //   processed.description = substituteVariables(processed.description, context);
+    // }
+    return processed;
+}
+// =============================================================================
+// Layer Organization Functions
+// =============================================================================
+/**
+ * Transform deep layer frame analysis results from displayResults format to frontend-expected format.
+ *
+ * This function is a generic data pass-through that:
+ * 1. Maps step IDs to output property names (e.g., 'quadrant_analysis' → 'quadrants')
+ * 2. Converts table format { columns, rows } to object array
+ * 3. Passes through data without field-level transformations
+ *
+ * Field naming is the responsibility of the Skill YAML, not this function.
+ * The Skill YAML should output data with field names that match frontend expectations.
+ */
+function transformDeepFrameAnalysis(displayResults) {
+    logger_1.default.debug('SkillExecutor', `transformDeepFrameAnalysis: ${displayResults.length} steps [${displayResults.map(dr => dr.stepId).join(', ')}]`);
+    const fullAnalysis = {
+        quadrants: { main_thread: {}, render_thread: {} },
+        binder_calls: [],
+        cpu_frequency: { big_avg_mhz: 0, little_avg_mhz: 0 },
+        main_thread_slices: [],
+        render_thread_slices: [],
+        cpu_freq_timeline: [],
+        lock_contentions: [],
+    };
+    let diagnosisSummary = '';
+    // Step ID to output property mapping
+    // This configuration defines which step output goes to which analysis property
+    const stepIdMapping = {
+        'binder_calls': 'binder_calls',
+        'binder_data': 'binder_calls',
+        'main_thread_slices': 'main_thread_slices',
+        'main_slices': 'main_thread_slices',
+        'render_thread_slices': 'render_thread_slices',
+        'render_slices': 'render_thread_slices',
+        'cpu_freq_timeline': 'cpu_freq_timeline',
+        'freq_timeline': 'cpu_freq_timeline',
+        'lock_contention': 'lock_contentions',
+        'lock_data': 'lock_contentions',
+    };
+    for (const dr of displayResults) {
+        const stepId = dr.stepId;
+        const rawData = dr.data;
+        // Handle both array data and table format { columns, rows }
+        let dataArray = [];
+        if (Array.isArray(rawData)) {
+            dataArray = rawData;
+        }
+        else if (rawData?.rows && rawData?.columns) {
+            // Convert table format to object array (generic transformation)
+            dataArray = rawData.rows.map((row) => {
+                const obj = {};
+                rawData.columns.forEach((col, idx) => {
+                    obj[col] = row[idx];
+                });
+                return obj;
+            });
+        }
+        // Handle diagnostic step specially (extracts diagnosis text)
+        if (stepId === 'frame_diagnosis') {
+            const diagnostics = rawData?.diagnostics || [];
+            if (Array.isArray(diagnostics) && diagnostics.length > 0) {
+                diagnosisSummary = diagnostics
+                    .filter((d) => d.diagnosis)
+                    .map((d) => d.diagnosis)
+                    .join('; ');
+                logger_1.default.debug('SkillExecutor', `frame_diagnosis: ${diagnostics.length} diagnostics`);
+            }
+            continue;
+        }
+        // Handle root_cause_summary step - extract primary_cause as diagnosis
+        // stepId is 'root_cause_summary' (from skill step id), not 'root_cause' (save_as variable name)
+        if (stepId === 'root_cause_summary') {
+            // Extract primary_cause as the main diagnosis
+            if (dataArray.length > 0) {
+                const rootCause = dataArray[0];
+                if (rootCause?.primary_cause) {
+                    // Use root_cause as primary diagnosis (more reliable than frame_diagnosis rules)
+                    diagnosisSummary = rootCause.primary_cause;
+                    if (rootCause.secondary_info) {
+                        diagnosisSummary += ` (${rootCause.secondary_info})`;
+                    }
+                }
+            }
+            continue;
+        }
+        // Handle cpu_freq_analysis specially (converts rows to single object)
+        if (stepId === 'cpu_freq_analysis' || stepId === 'freq_data') {
+            const bigCore = dataArray.find((d) => d.core_type === 'big');
+            const littleCore = dataArray.find((d) => d.core_type === 'little');
+            fullAnalysis.cpu_frequency = {
+                big_avg_mhz: bigCore?.avg_freq_mhz || 0,
+                little_avg_mhz: littleCore?.avg_freq_mhz || 0,
+            };
+            continue;
+        }
+        // Handle quadrant_analysis specially - convert flat array to nested object
+        // Input format: [{ quadrant: "MainThread Q1_大核运行", dur_ms, percentage }, ...]
+        // Output format: { main_thread: { q1, q2, q3, q4 }, render_thread: { q1, q2, q3, q4 } }
+        if (stepId === 'quadrant_analysis' || stepId === 'quadrant_data') {
+            const mainThread = { q1: 0, q2: 0, q3: 0, q4: 0 };
+            const renderThread = { q1: 0, q2: 0, q3: 0, q4: 0 };
+            for (const item of dataArray) {
+                const quadrant = item.quadrant || item.name || '';
+                const percentage = item.percentage || 0;
+                // Parse quadrant name: "MainThread Q1_大核运行" -> thread=MainThread, q=1
+                if (quadrant.includes('MainThread')) {
+                    if (quadrant.includes('Q1'))
+                        mainThread.q1 = percentage;
+                    else if (quadrant.includes('Q2'))
+                        mainThread.q2 = percentage;
+                    else if (quadrant.includes('Q3'))
+                        mainThread.q3 = percentage;
+                    // Q4a (IO-block) + Q4b (voluntary sleep) both contribute to Q4 total
+                    else if (quadrant.includes('Q4'))
+                        mainThread.q4 = (mainThread.q4 || 0) + percentage;
+                }
+                else if (quadrant.includes('RenderThread')) {
+                    if (quadrant.includes('Q1'))
+                        renderThread.q1 = percentage;
+                    else if (quadrant.includes('Q2'))
+                        renderThread.q2 = percentage;
+                    else if (quadrant.includes('Q3'))
+                        renderThread.q3 = percentage;
+                    else if (quadrant.includes('Q4'))
+                        renderThread.q4 = (renderThread.q4 || 0) + percentage;
+                }
+            }
+            fullAnalysis.quadrants = {
+                main_thread: mainThread,
+                render_thread: renderThread,
+            };
+            continue;
+        }
+        // Generic pass-through: map step ID to property and assign data directly
+        const outputProperty = stepIdMapping[stepId];
+        if (outputProperty && dataArray.length > 0) {
+            // Map field names to match what renderDeepFrameAnalysis expects
+            if (outputProperty === 'binder_calls') {
+                // Skill outputs: interface, count, dur_ms, max_ms, sync_count
+                // Renderer expects: server_process, call_count, total_ms, max_ms
+                fullAnalysis[outputProperty] = dataArray.map((item) => ({
+                    server_process: item.interface || item.server_process || '',
+                    call_count: item.count || item.call_count || 0,
+                    total_ms: item.dur_ms || item.total_ms || 0,
+                    max_ms: item.max_ms || 0,
+                    sync_count: item.sync_count || 0,
+                }));
+            }
+            else if (outputProperty === 'main_thread_slices' || outputProperty === 'render_thread_slices') {
+                // Skill outputs: name, dur_ms, count, max_ms, ts
+                // Renderer expects: name, total_ms, count, max_ms
+                fullAnalysis[outputProperty] = dataArray.map((item) => ({
+                    name: item.name || '',
+                    total_ms: item.dur_ms || item.total_ms || 0,
+                    count: item.count || 1,
+                    max_ms: item.max_ms || 0,
+                    ts: item.ts,
+                }));
+            }
+            else {
+                fullAnalysis[outputProperty] = dataArray;
+            }
+        }
+    }
+    return {
+        diagnosis_summary: diagnosisSummary || '暂无明显问题',
+        full_analysis: fullAnalysis,
+    };
+}
+function organizeByLayer(steps) {
+    const layers = {
+        overview: {},
+        list: {},
+        session: {},
+        deep: {},
+        diagnosis: {},
+    };
+    for (const step of steps) {
+        const rawLayer = step.display?.layer;
+        if (!rawLayer) {
+            continue;
+        }
+        // 规范化 layer 名称为语义名称（overview/list/session/deep/diagnosis）
+        const layer = normalizeLayer(rawLayer) || rawLayer;
+        // Ensure failed steps have empty array data for consistent handling
+        const normalizedStep = step.success ? step : {
+            ...step,
+            data: [], // Default to empty array for failed steps
+            error: step.error,
+        };
+        switch (layer) {
+            case 'overview':
+            case 'list':
+            case 'diagnosis':
+                const targetLayer = layers[layer];
+                if (targetLayer) {
+                    targetLayer[normalizedStep.stepId] = normalizedStep;
+                }
+                break;
+            case 'session':
+                // session 数据需要按 session_id 组织
+                const sessionLayer = layers.session;
+                if (sessionLayer) {
+                    const sessionId = extractSessionId(normalizedStep);
+                    if (!sessionLayer[sessionId]) {
+                        sessionLayer[sessionId] = {};
+                    }
+                    sessionLayer[sessionId][normalizedStep.stepId] = normalizedStep;
+                }
+                break;
+            case 'deep':
+                // deep 数据需要按 session_id 和 frame_id 组织
+                const deepLayer = layers.deep;
+                if (deepLayer) {
+                    // 特殊处理 iterator 结果：每个迭代项都是单独的 deep 条目
+                    if (normalizedStep.stepType === 'iterator' && Array.isArray(normalizedStep.data)) {
+                        logger_1.default.debug('SkillExecutor', `organizeByLayer: iterator step ${normalizedStep.stepId} with ${normalizedStep.data.length} items`);
+                        // Iterator 返回 { itemIndex, item, result }[] 数组
+                        for (let i = 0; i < normalizedStep.data.length; i++) {
+                            const iterItem = normalizedStep.data[i];
+                            const item = iterItem?.item;
+                            if (!item) {
+                                console.warn(`[organizeByLayer] Iterator item ${i} has no item data, skipping`);
+                                continue;
+                            }
+                            const frameId = `frame_${item.frame_id || item.frame_index || i}`;
+                            const sessionId = `session_${item.session_id ?? 0}`;
+                            if (!deepLayer[sessionId]) {
+                                deepLayer[sessionId] = {};
+                            }
+                            // Transform displayResults into format expected by frontend
+                            const displayResults = iterItem.result?.displayResults || [];
+                            const transformedData = transformDeepFrameAnalysis(displayResults);
+                            const frameStepResult = {
+                                stepId: frameId,
+                                stepType: 'atomic',
+                                success: iterItem.result?.success ?? false,
+                                data: transformedData,
+                                executionTimeMs: iterItem.result?.executionTimeMs || 0,
+                                display: {
+                                    title: `帧 #${item.frame_id || item.frame_index || i} - ${item.jank_type || 'Unknown'}`,
+                                    level: 'key',
+                                    layer: 'deep',
+                                    format: 'table',
+                                },
+                            };
+                            frameStepResult.item = item;
+                            deepLayer[sessionId][frameId] = frameStepResult;
+                        }
+                        logger_1.default.debug('SkillExecutor', `organizeByLayer: deep layer sessions: [${Object.keys(deepLayer).join(', ')}]`);
+                    }
+                    else if (normalizedStep.stepType === 'atomic' && Array.isArray(normalizedStep.data) && normalizedStep.data.length > 0) {
+                        // 检查是否是帧列表数据（如 get_app_jank_frames）
+                        // 如果 data 是数组且每个元素都有 frame_id 或 frame_index，展开为多个帧
+                        const firstItem = normalizedStep.data[0];
+                        const hasFrameId = firstItem && typeof firstItem === 'object' && ('frame_id' in firstItem || 'frame_index' in firstItem);
+                        if (hasFrameId) {
+                            // 将每一行作为一个单独的帧条目
+                            for (let i = 0; i < normalizedStep.data.length; i++) {
+                                const item = normalizedStep.data[i];
+                                if (!item || typeof item !== 'object')
+                                    continue;
+                                const frameId = `frame_${item.frame_id || item.frame_index || i}`;
+                                const sessionId = `session_${item.session_id ?? 0}`;
+                                if (!deepLayer[sessionId]) {
+                                    deepLayer[sessionId] = {};
+                                }
+                                const frameStepResult = {
+                                    stepId: frameId,
+                                    stepType: 'atomic',
+                                    success: normalizedStep.success,
+                                    data: [item],
+                                    executionTimeMs: normalizedStep.executionTimeMs / normalizedStep.data.length,
+                                    display: {
+                                        title: `帧 #${item.frame_id || item.frame_index || i} - ${item.jank_type || 'Unknown'}`,
+                                        level: 'key',
+                                        layer: 'deep',
+                                        format: 'table',
+                                    },
+                                };
+                                frameStepResult.item = item;
+                                deepLayer[sessionId][frameId] = frameStepResult;
+                            }
+                        }
+                        else {
+                            // 普通的 deep 步骤（不是帧列表）
+                            const sessionId = extractSessionId(normalizedStep);
+                            const frameId = extractFrameId(normalizedStep);
+                            if (!deepLayer[sessionId]) {
+                                deepLayer[sessionId] = {};
+                            }
+                            deepLayer[sessionId][frameId] = normalizedStep;
+                        }
+                    }
+                    else {
+                        // 普通的 deep 步骤
+                        const sessionId = extractSessionId(normalizedStep);
+                        const frameId = extractFrameId(normalizedStep);
+                        if (!deepLayer[sessionId]) {
+                            deepLayer[sessionId] = {};
+                        }
+                        deepLayer[sessionId][frameId] = normalizedStep;
+                    }
+                }
+                break;
+        }
+    }
+    return layers;
+}
+function extractSessionId(step) {
+    // 尝试从 step.data 中提取 session_id
+    if (Array.isArray(step.data) && step.data.length > 0) {
+        return `session_${step.data[0].session_id ?? 0}`;
+    }
+    return 'session_0';
+}
+function extractFrameId(step) {
+    // 尝试从 step 中提取 frame_id
+    if (step.stepId.startsWith('frame_')) {
+        return step.stepId;
+    }
+    if (Array.isArray(step.data) && step.data.length > 0) {
+        return `frame_${step.data[0].frame_index ?? step.data[0].frame_id ?? 0}`;
+    }
+    // For non-frame deep steps, use stepId as key to avoid overwriting previous steps.
+    if (step.stepId && step.stepId.length > 0) {
+        return step.stepId;
+    }
+    return 'frame_0';
+}
+// =============================================================================
+// Skill Executor
+// =============================================================================
+class SkillExecutor {
+    constructor(traceProcessor, aiService, eventEmitter) {
+        this.fragmentRegistry = new Map();
+        this.identityGate = new identityGate_1.IdentityGate();
+        this.processIdentityCache = new Map();
+        this.traceProcessor = traceProcessor;
+        this.aiService = aiService;
+        this.eventEmitter = eventEmitter;
+        this.skillRegistry = new Map();
+    }
+    /**
+     * Set the SQL fragment registry (loaded by SkillRegistry).
+     * Fragments are reusable CTE definitions injected into step SQL at runtime.
+     */
+    setFragmentRegistry(cache) {
+        this.fragmentRegistry = cache;
+    }
+    /**
+     * Inject SQL fragment CTEs into a step's SQL query.
+     *
+     * Fragment files contain bare CTE definitions (no WITH keyword), e.g.:
+     *   target_threads AS (SELECT ...)
+     *
+     * Injection rules:
+     * - If the SQL starts with WITH: insert fragments after WITH, before existing CTEs
+     * - Otherwise: wrap as WITH <fragments>\n<sql>
+     */
+    injectSqlFragments(sql, fragmentPaths, context) {
+        const fragmentCteBodies = [];
+        for (const fragPath of fragmentPaths) {
+            const content = this.fragmentRegistry.get(fragPath);
+            if (!content) {
+                logger_1.default.warn('SkillExecutor', `Fragment not found: ${fragPath}, skipping`);
+                continue;
+            }
+            // Apply variable substitution to the fragment content
+            const substituted = substituteVariables(content, context);
+            fragmentCteBodies.push(substituted);
+        }
+        if (fragmentCteBodies.length === 0)
+            return sql;
+        const fragmentBlock = fragmentCteBodies.join(',\n');
+        const trimmed = sql.trimStart();
+        // Strip leading SQL single-line comments (-- ...) before WITH detection,
+        // since steps like root_cause_summary prefix SQL with comment lines.
+        const noLeadingComments = trimmed.replace(/^(--[^\n]*\n\s*)*/g, '');
+        const withMatch = noLeadingComments.match(/^WITH\s+/i);
+        if (withMatch) {
+            // Preserve original comments, insert fragments after WITH
+            const commentPrefix = trimmed.slice(0, trimmed.length - noLeadingComments.length);
+            const afterWith = noLeadingComments.slice(withMatch[0].length);
+            return `${commentPrefix}WITH\n${fragmentBlock},\n${afterWith}`;
+        }
+        // Wrap the entire SQL in a WITH clause
+        return `WITH\n${fragmentBlock}\n${trimmed}`;
+    }
+    /**
+     * 注册 skill
+     */
+    registerSkill(skill) {
+        this.skillRegistry.set(skill.name, skill);
+    }
+    /**
+     * 批量注册 skills
+     */
+    registerSkills(skills) {
+        for (const skill of skills) {
+            this.registerSkill(skill);
+        }
+    }
+    /**
+     * 发送事件到前端
+     */
+    emit(event) {
+        if (this.eventEmitter) {
+            this.eventEmitter({
+                ...event,
+                timestamp: Date.now(),
+            });
+        }
+    }
+    buildIdentityCacheKey(traceId, target) {
+        return JSON.stringify({
+            traceId,
+            requestedName: target.requestedName || '',
+            threadName: target.threadName || '',
+            upid: target.upid ?? null,
+            pid: target.pid ?? null,
+            startTs: target.startTs ?? null,
+            endTs: target.endTs ?? null,
+        });
+    }
+    toNumber(value) {
+        if (value === undefined || value === null || value === '')
+            return undefined;
+        const n = Number(value);
+        return Number.isFinite(n) ? n : undefined;
+    }
+    splitSources(...values) {
+        const sources = new Set();
+        for (const value of values) {
+            if (typeof value !== 'string')
+                continue;
+            for (const part of value.split(',')) {
+                const s = part.trim();
+                if (s)
+                    sources.add(s);
+            }
+        }
+        return Array.from(sources);
+    }
+    rowToIdentityCandidate(row) {
+        return {
+            rank: this.toNumber(row.rank) ?? 0,
+            confidenceScore: this.toNumber(row.confidence_score) ?? 0,
+            rawStatus: row.identity_status ? String(row.identity_status) : undefined,
+            canonicalPackageName: row.canonical_package_name ? String(row.canonical_package_name) : undefined,
+            recommendedProcessNameParam: row.recommended_process_name_param ? String(row.recommended_process_name_param) : undefined,
+            upid: this.toNumber(row.upid),
+            pid: this.toNumber(row.pid),
+            processName: row.process_name ? String(row.process_name) : undefined,
+            metadataProcessName: row.metadata_process_name ? String(row.metadata_process_name) : undefined,
+            packageName: row.package_name ? String(row.package_name) : undefined,
+            cmdline: row.cmdline ? String(row.cmdline) : undefined,
+            targetMatchSources: row.target_match_sources ? String(row.target_match_sources) : undefined,
+            supportingSources: row.supporting_sources ? String(row.supporting_sources) : undefined,
+            identityWarning: row.identity_warning ? String(row.identity_warning) : undefined,
+        };
+    }
+    normalizeIdentityStatus(candidate) {
+        if (!candidate)
+            return 'not_found';
+        if ((candidate.rawStatus === 'confirmed' || candidate.rawStatus === 'probable') &&
+            candidate.confidenceScore >= 50) {
+            return 'verified';
+        }
+        if (candidate.confidenceScore <= 0)
+            return 'not_found';
+        return 'ambiguous';
+    }
+    async resolveProcessIdentityForGate(traceId, target, inherited) {
+        const cacheKey = this.buildIdentityCacheKey(traceId, target);
+        const cached = this.processIdentityCache.get(cacheKey);
+        if (cached)
+            return cached;
+        const params = {
+            max_rows: 10,
+        };
+        if (target.requestedName) {
+            params.package = target.requestedName;
+            params.process_name = target.requestedName;
+        }
+        if (target.threadName)
+            params.thread_name = target.threadName;
+        if (target.upid !== undefined)
+            params.upid = target.upid;
+        if (target.pid !== undefined)
+            params.pid = target.pid;
+        if (target.startTs !== undefined)
+            params.start_ts = target.startTs;
+        if (target.endTs !== undefined)
+            params.end_ts = target.endTs;
+        let resolution;
+        try {
+            const result = await this.execute('process_identity_resolver', traceId, params, { ...inherited, __skipIdentityGate: true });
+            if (!result.success) {
+                resolution = {
+                    status: 'unresolved',
+                    requestedName: target.requestedName,
+                    upids: [],
+                    confidenceScore: 0,
+                    evidenceSources: [],
+                    warnings: [],
+                    candidates: [],
+                    resolverError: result.error || 'process_identity_resolver failed',
+                };
+            }
+            else {
+                const rows = Array.isArray(result.rawResults?.root?.data)
+                    ? result.rawResults.root.data
+                    : [];
+                const candidates = rows.map(row => this.rowToIdentityCandidate(row));
+                const top = candidates[0];
+                const warning = top?.identityWarning && top.identityWarning !== 'ok' ? top.identityWarning : undefined;
+                resolution = {
+                    status: this.normalizeIdentityStatus(top),
+                    requestedName: target.requestedName,
+                    canonicalPackageName: top?.canonicalPackageName,
+                    recommendedProcessNameParam: top?.recommendedProcessNameParam,
+                    upids: candidates.map(c => c.upid).filter((upid) => upid !== undefined),
+                    confidenceScore: top?.confidenceScore ?? 0,
+                    rawStatus: top?.rawStatus,
+                    evidenceSources: this.splitSources(top?.targetMatchSources, top?.supportingSources),
+                    warnings: warning ? [warning] : [],
+                    candidates,
+                };
+            }
+        }
+        catch (error) {
+            resolution = {
+                status: 'unresolved',
+                requestedName: target.requestedName,
+                upids: [],
+                confidenceScore: 0,
+                evidenceSources: [],
+                warnings: [],
+                candidates: [],
+                resolverError: error?.message || 'process_identity_resolver threw',
+            };
+        }
+        if (!resolution.resolverError) {
+            this.processIdentityCache.set(cacheKey, resolution);
+        }
+        return resolution;
+    }
+    async applyIdentityGate(skill, traceId, params, inherited) {
+        return this.identityGate.apply({
+            traceId,
+            skill,
+            params,
+            inherited,
+            resolve: (target) => this.resolveProcessIdentityForGate(traceId, target, inherited),
+        });
+    }
+    buildIdentityBlockedResult(skillId, skill, startTime, gate) {
+        const error = gate.error || `Process identity gate blocked skill: ${skillId}`;
+        return {
+            skillId,
+            skillName: skill.meta.display_name,
+            success: false,
+            displayResults: [],
+            diagnostics: [{
+                    id: 'process_identity_gate_blocked',
+                    diagnosis: error,
+                    confidence: 1,
+                    severity: 'critical',
+                    evidence: {
+                        target: gate.target,
+                        resolution: gate.resolution,
+                        policy: gate.config.policy,
+                    },
+                    suggestions: [
+                        '先确认目标应用身份；如果候选进程不唯一，请使用用户明确包名、线程名或 UPID 重新运行。',
+                        '报告中使用 canonicalPackageName，旧 Skill 参数使用 recommendedProcessNameParam。',
+                    ],
+                    source: 'rule',
+                }],
+            executionTimeMs: Date.now() - startTime,
+            error,
+        };
+    }
+    /**
+     * Expand prerequisite module aliases to canonical stdlib module ids.
+     */
+    resolvePrerequisiteModules(modules) {
+        if (!Array.isArray(modules) || modules.length === 0)
+            return [];
+        const expanded = [];
+        for (const m of modules) {
+            switch (m) {
+                case 'sched':
+                    // stdlib/sched/ 下不存在 sched.sql；常用能力在 states/runnable
+                    expanded.push('sched.states', 'sched.runnable');
+                    break;
+                case 'stack_profile':
+                    // stdlib/callstacks/stack_profile.sql
+                    expanded.push('callstacks.stack_profile');
+                    break;
+                case 'android.frames':
+                    // stdlib/android/frames/ 无 frames.sql；常见能力来自 timeline/jank_type
+                    expanded.push('android.frames.timeline', 'android.frames.jank_type');
+                    break;
+                case 'android.frames.jank':
+                    // 实际模块名为 jank_type.sql
+                    expanded.push('android.frames.jank_type');
+                    break;
+                default:
+                    expanded.push(m);
+            }
+        }
+        return Array.from(new Set(expanded));
+    }
+    /**
+     * Best-effort probe for prerequisite modules and return only available ones.
+     * Note: some trace processor builds treat INCLUDE as statement-scoped, so
+     * SQL execution still prepends INCLUDE per-step for determinism.
+     */
+    async resolveAvailableModules(traceId, modules) {
+        const available = [];
+        for (const module of modules) {
+            try {
+                const includeResult = await this.traceProcessor.query(traceId, `INCLUDE PERFETTO MODULE ${module};`);
+                if (includeResult?.error) {
+                    console.warn(`[SkillExecutor] Module not available: ${module}`);
+                    continue;
+                }
+                available.push(module);
+            }
+            catch {
+                console.warn(`[SkillExecutor] Module not available: ${module}`);
+            }
+        }
+        return available;
+    }
+    /**
+     * Prefix SQL with prerequisite INCLUDE statements.
+     */
+    buildSqlWithModuleIncludes(sql, context) {
+        const modules = context.moduleIncludes || [];
+        if (modules.length === 0)
+            return sql;
+        const prefix = modules.map(module => `INCLUDE PERFETTO MODULE ${module};`).join('\n');
+        return `${prefix}\n${sql}`;
+    }
+    /**
+     * 执行 skill
+     */
+    async execute(skillId, traceId, params = {}, inherited = {}) {
+        const startTime = Date.now();
+        const skill = this.skillRegistry.get(skillId);
+        if (!skill) {
+            return {
+                skillId,
+                skillName: skillId,
+                success: false,
+                displayResults: [],
+                diagnostics: [],
+                executionTimeMs: Date.now() - startTime,
+                error: `Skill not found: ${skillId}`,
+            };
+        }
+        this.emit({
+            type: 'skill_started',
+            skillId,
+            data: { skillName: skill.meta.display_name },
+        });
+        const gate = await this.applyIdentityGate(skill, traceId, params, inherited);
+        if (!gate.allowed) {
+            this.emit({
+                type: 'skill_error',
+                skillId,
+                data: { error: gate.error },
+            });
+            return this.buildIdentityBlockedResult(skillId, skill, startTime, gate);
+        }
+        // Validate and coerce input parameters against skill.inputs declarations
+        const validated = (0, skillValidator_1.validateSkillInputs)(skillId, skill.inputs, gate.params);
+        for (const w of validated.warnings) {
+            logger_1.default.warn('SkillExecutor', `[${skillId}] ${w.paramName}: ${w.message}`);
+        }
+        if (validated.errors.length > 0) {
+            const msg = validated.errors.map(e => `${e.paramName}: ${e.message}`).join('; ');
+            logger_1.default.error('SkillExecutor', `[${skillId}] Input validation failed: ${msg}`);
+            return {
+                skillId,
+                skillName: skill.meta.display_name,
+                success: false,
+                displayResults: [],
+                diagnostics: [],
+                executionTimeMs: Date.now() - startTime,
+                error: `Input validation failed: ${msg}`,
+            };
+        }
+        const prerequisiteModules = this.resolvePrerequisiteModules(skill.prerequisites?.modules);
+        let moduleIncludes = prerequisiteModules;
+        // 仅注入可用模块，避免未知模块导致整条 SQL 失败
+        if (prerequisiteModules.length > 0) {
+            moduleIncludes = await this.resolveAvailableModules(traceId, prerequisiteModules);
+        }
+        // 创建执行上下文 (use validated.params with coerced types and defaults)
+        const context = {
+            traceId,
+            params: validated.params,
+            inherited: gate.inherited,
+            results: {},
+            variables: {},
+            moduleIncludes,
+        };
+        // 检查表依赖
+        const prereqCheck = await this.checkPrerequisites(skill, traceId);
+        if (!prereqCheck.success) {
+            return {
+                skillId,
+                skillName: skill.meta.display_name,
+                success: false,
+                displayResults: [],
+                diagnostics: [],
+                executionTimeMs: Date.now() - startTime,
+                error: `Skipped: ${prereqCheck.error}`,
+            };
+        }
+        try {
+            const displayResults = [];
+            const diagnostics = [];
+            const synthesizeData = [];
+            let aiSummary;
+            // 根据 skill 类型执行
+            switch (skill.type) {
+                case 'atomic':
+                    if (skill.sql) {
+                        const atomicResult = await this.executeAtomicSkill(skill, context);
+                        // Handle atomic skill errors
+                        if (!atomicResult.success) {
+                            this.emit({
+                                type: 'skill_error',
+                                skillId,
+                                data: { error: atomicResult.error },
+                            });
+                            return {
+                                skillId,
+                                skillName: skill.meta.display_name,
+                                success: false,
+                                displayResults: [],
+                                diagnostics: [],
+                                executionTimeMs: Date.now() - startTime,
+                                error: atomicResult.error,
+                            };
+                        }
+                        // Keep parity with step-based execution so referenced atomic skills
+                        // can expose their payload via rawResults.root.data.
+                        context.results['root'] = atomicResult;
+                        if (atomicResult.display) {
+                            displayResults.push(this.createDisplayResult('root', skill.meta.display_name, atomicResult, skill.output?.display));
+                        }
+                    }
+                    else {
+                        // Backward compatibility: some "atomic" skills are authored as step-based YAML.
+                        // Treat them as composite execution when `sql` is absent but `steps` exist.
+                        if (!skill.steps || skill.steps.length === 0) {
+                            return {
+                                skillId,
+                                skillName: skill.meta.display_name,
+                                success: false,
+                                displayResults: [],
+                                diagnostics: [],
+                                executionTimeMs: Date.now() - startTime,
+                                error: 'No SQL or steps defined for atomic skill',
+                            };
+                        }
+                        const stepExec = await this.executeStepBasedSkill(skill, skillId, context, displayResults, diagnostics, synthesizeData);
+                        aiSummary = stepExec.aiSummary;
+                    }
+                    break;
+                case 'composite':
+                case 'iterator':
+                case 'diagnostic':
+                case 'ai_decision':
+                case 'ai_summary':
+                case 'pipeline':
+                    {
+                        if (!skill.steps || skill.steps.length === 0) {
+                            return {
+                                skillId,
+                                skillName: skill.meta.display_name,
+                                success: false,
+                                displayResults: [],
+                                diagnostics: [],
+                                executionTimeMs: Date.now() - startTime,
+                                error: `No steps defined for skill: ${skillId}`,
+                            };
+                        }
+                        const stepExec = await this.executeStepBasedSkill(skill, skillId, context, displayResults, diagnostics, synthesizeData);
+                        aiSummary = stepExec.aiSummary;
+                    }
+                    break;
+                case 'pipeline_definition':
+                case 'comparison':
+                    return {
+                        skillId,
+                        skillName: skill.meta.display_name,
+                        success: false,
+                        displayResults: [],
+                        diagnostics: [],
+                        executionTimeMs: Date.now() - startTime,
+                        error: `Skill type '${skill.type}' is metadata-only and not executable by the single-trace SkillExecutor: ${skillId}`,
+                    };
+            }
+            // If skills provide data-driven synthesize configs, generate a deterministic
+            // "insight summary" DisplayResult so Agents can cite KPIs/insights without LLM.
+            // Best-effort and only triggers for config.role === 'overview'.
+            const synthesizeSummary = this.buildSynthesizeSummaryDisplayResult(synthesizeData);
+            if (synthesizeSummary) {
+                displayResults.unshift(synthesizeSummary);
+            }
+            this.emit({
+                type: 'skill_completed',
+                skillId,
+                data: {
+                    success: true,
+                    displayResultsCount: displayResults.length,
+                    diagnosticsCount: diagnostics.length,
+                },
+            });
+            return {
+                skillId,
+                skillName: skill.meta.display_name,
+                success: true,
+                displayResults,
+                diagnostics,
+                aiSummary,
+                synthesizeData: synthesizeData.length > 0 ? synthesizeData : undefined,
+                rawResults: context.results,
+                executionTimeMs: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            this.emit({
+                type: 'skill_error',
+                skillId,
+                data: { error: error.message },
+            });
+            return {
+                skillId,
+                skillName: skill.meta.display_name,
+                success: false,
+                displayResults: [],
+                diagnostics: [],
+                executionTimeMs: Date.now() - startTime,
+                error: error.message,
+            };
+        }
+    }
+    /**
+     * Execute a step-based skill (composite/iterator/diagnostic, and legacy atomic skills without root-level `sql`).
+     * Mutates `context.results` / `context.variables` and appends into `displayResults` / `diagnostics` / `synthesizeData`.
+     */
+    extractSaveAsValue(stepResult) {
+        // Most steps already store direct row arrays/objects in stepResult.data.
+        if (stepResult.stepType !== 'skill') {
+            return stepResult.data;
+        }
+        const nested = stepResult.data;
+        if (!nested || typeof nested !== 'object') {
+            return stepResult.data;
+        }
+        // Future-proof: if nested result already exposes .data directly, use it.
+        if (Object.prototype.hasOwnProperty.call(nested, 'data')) {
+            return nested.data;
+        }
+        // SkillExecutionResult currently exposes payloads via rawResults.
+        const rawResults = nested.rawResults;
+        if (rawResults && typeof rawResults === 'object') {
+            if (rawResults.root?.data !== undefined) {
+                return rawResults.root.data;
+            }
+            for (const step of Object.values(rawResults)) {
+                if (step && typeof step === 'object' && Object.prototype.hasOwnProperty.call(step, 'data')) {
+                    return step.data;
+                }
+            }
+        }
+        return stepResult.data;
+    }
+    async executeStepBasedSkill(skill, skillId, context, displayResults, diagnostics, synthesizeData) {
+        let aiSummary;
+        if (!skill.steps) {
+            return { aiSummary };
+        }
+        for (const step of skill.steps) {
+            const stepResult = await this.executeStep(step, context, skillId);
+            // Collect synthesize-marked data for downstream summarization (execute path parity).
+            // Supports:
+            // 1) synthesize: true (legacy)
+            // 2) synthesize: { role: ..., fields: ... } (data-driven)
+            if ('synthesize' in step && step.synthesize) {
+                const synthesizeValue = step.synthesize;
+                const displayConfig = this.getDisplayConfig(step) || {};
+                let config;
+                if (typeof synthesizeValue === 'object' && synthesizeValue.role) {
+                    config = synthesizeValue;
+                }
+                synthesizeData.push({
+                    stepId: step.id,
+                    stepName: ('name' in step ? step.name : step.id) || step.id,
+                    stepType: typeof step.type === 'string' ? step.type : 'skill',
+                    layer: displayConfig.layer,
+                    data: stepResult.data,
+                    success: stepResult.success,
+                    config,
+                });
+            }
+            if (stepResult.success) {
+                // 保存结果
+                context.results[step.id] = stepResult;
+                // 如果有 save_as，保存到变量
+                if ('save_as' in step && step.save_as) {
+                    context.variables[step.save_as] = this.extractSaveAsValue(stepResult);
+                }
+                // 收集需要展示的结果
+                if (this.shouldDisplay(step)) {
+                    // Substitute template variables (e.g., ${startup_id}) in display config
+                    const rawDisplay = this.getDisplayConfig(step);
+                    const processedDisplay = rawDisplay ? processDisplayConfig(rawDisplay, context) : undefined;
+                    displayResults.push(this.createDisplayResult(step.id, ('name' in step ? step.name : step.id) || step.id, stepResult, processedDisplay, ('sql' in step ? step.sql : undefined)));
+                }
+                // Iterator 结果绑回源列表：将 expandableData 绑定到 source step 的 DisplayResult
+                if (step.type === 'iterator' && 'source' in step && step.source) {
+                    const sourceName = step.source;
+                    // source 引用的是 save_as 名称，需要找到对应的 step.id
+                    const sourceStep = skill.steps.find((s) => s.save_as === sourceName || s.id === sourceName);
+                    const sourceStepId = sourceStep ? sourceStep.id : sourceName;
+                    const sourceDisplayResult = displayResults.find(dr => dr.stepId === sourceStepId);
+                    // expandableData 在 DisplayResult.data 中（由 flattenIteratorResults 创建）
+                    const iteratorDisplayResult = displayResults.find(dr => dr.stepId === step.id);
+                    if (sourceDisplayResult?.data && iteratorDisplayResult?.data?.expandableData) {
+                        sourceDisplayResult.data.expandableData = iteratorDisplayResult.data.expandableData;
+                    }
+                }
+                // 收集诊断结果
+                if (step.type === 'diagnostic' && stepResult.data?.diagnostics) {
+                    diagnostics.push(...stepResult.data.diagnostics);
+                }
+                // 收集 AI 总结
+                if (step.type === 'ai_summary' && stepResult.data?.summary) {
+                    aiSummary = stepResult.data.summary;
+                }
+            }
+        }
+        // Batch-to-expandable binding: bind batch step row data as expandableData for list steps.
+        // This avoids N+1 iterator queries by reusing a single batch SQL result.
+        this.applyExpandableBindSources(skill.steps, context, displayResults);
+        return { aiSummary };
+    }
+    /**
+     * Apply expandableBindSource declarations: for each step that declares an expandableBindSource,
+     * find the batch data in context.variables and bind it as expandableData on the target DisplayResult.
+     */
+    applyExpandableBindSources(steps, context, displayResults) {
+        for (const step of steps) {
+            const display = this.getDisplayConfig(step);
+            const bindSource = display?.expandableBindSource;
+            if (!bindSource)
+                continue;
+            const sourceData = context.variables[bindSource];
+            const targetDisplayResult = displayResults.find(dr => dr.stepId === step.id);
+            if (!Array.isArray(sourceData) || sourceData.length === 0)
+                continue;
+            if (!targetDisplayResult?.data?.rows?.length || !targetDisplayResult.data.columns?.length)
+                continue;
+            targetDisplayResult.data.expandableData = this.buildExpandableFromBatch(targetDisplayResult.data.rows, targetDisplayResult.data.columns, sourceData);
+        }
+    }
+    /**
+     * Build expandableData by matching batch source rows to target list rows.
+     *
+     * Matching strategy: both datasets are ordered by (session_id, frame_start), so
+     * we match by frame_index when available, falling back to start_ts, then positional index.
+     *
+     * Accepts two data shapes:
+     * - Columnar: targetRows (any[][]) + targetColumns (string[]) — from executeStepBasedSkill DisplayResults
+     * - Object array: targetObjects (Record<string, any>[]) — from executeCompositeSkill StepResults
+     */
+    buildExpandableFromBatch(targetRows, targetColumns, sourceData, targetObjects) {
+        const isColumnar = targetRows != null && targetColumns != null;
+        const rowCount = isColumnar ? targetRows.length : (targetObjects?.length ?? 0);
+        // Build lookup maps lazily — only construct the map if its matching column exists
+        const frameIndexCol = isColumnar ? targetColumns.indexOf('frame_index') : -1;
+        const hasFrameIndex = isColumnar ? frameIndexCol >= 0 : targetObjects?.some(o => o.frame_index != null);
+        const sessionIdCol = isColumnar ? targetColumns.indexOf('session_id') : -1;
+        const hasSessionId = isColumnar ? sessionIdCol >= 0 : targetObjects?.some(o => o.session_id != null);
+        const processNameCol = isColumnar ? targetColumns.indexOf('process_name') : -1;
+        const startTsCol = isColumnar ? targetColumns.indexOf('start_ts') : -1;
+        const hasStartTs = isColumnar ? startTsCol >= 0 : targetObjects?.some(o => o.start_ts != null);
+        let sourceByFrameIndex;
+        let sourceBySessionKey;
+        let sourceByStartTs;
+        if (hasFrameIndex) {
+            sourceByFrameIndex = new Map();
+            for (const row of sourceData) {
+                if (row.frame_index != null)
+                    sourceByFrameIndex.set(Number(row.frame_index), row);
+            }
+        }
+        // Composite key: process_name + session_id (for session-level expandable)
+        if (hasSessionId && !sourceByFrameIndex) {
+            sourceBySessionKey = new Map();
+            for (const row of sourceData) {
+                if (row.session_id != null) {
+                    const key = `${row.process_name ?? ''}::${row.session_id}`;
+                    sourceBySessionKey.set(key, row);
+                }
+            }
+        }
+        if (hasStartTs && !sourceByFrameIndex && !sourceBySessionKey) {
+            sourceByStartTs = new Map();
+            for (const row of sourceData) {
+                if (row.start_ts != null)
+                    sourceByStartTs.set(String(row.start_ts), row);
+            }
+        }
+        const expandableData = [];
+        for (let i = 0; i < rowCount; i++) {
+            // Get matching keys without constructing the full item yet
+            let frameIndexVal;
+            let sessionIdVal;
+            let processNameVal;
+            let startTsVal;
+            if (isColumnar) {
+                const row = targetRows[i];
+                if (frameIndexCol >= 0)
+                    frameIndexVal = row[frameIndexCol];
+                if (sessionIdCol >= 0)
+                    sessionIdVal = row[sessionIdCol];
+                if (processNameCol >= 0)
+                    processNameVal = row[processNameCol];
+                if (startTsCol >= 0)
+                    startTsVal = row[startTsCol];
+            }
+            else {
+                const obj = targetObjects[i];
+                frameIndexVal = obj.frame_index;
+                sessionIdVal = obj.session_id;
+                processNameVal = obj.process_name;
+                startTsVal = obj.start_ts;
+            }
+            // Find matching source row: frame_index → session_key → start_ts → positional
+            let matched;
+            if (sourceByFrameIndex && frameIndexVal != null) {
+                matched = sourceByFrameIndex.get(Number(frameIndexVal));
+            }
+            if (!matched && sourceBySessionKey && sessionIdVal != null) {
+                const key = `${processNameVal ?? ''}::${sessionIdVal}`;
+                matched = sourceBySessionKey.get(key);
+            }
+            if (!matched && sourceByStartTs && startTsVal != null) {
+                matched = sourceByStartTs.get(String(startTsVal));
+            }
+            if (!matched && i < sourceData.length) {
+                matched = sourceData[i];
+            }
+            if (!matched) {
+                // Push undefined for unmatched rows — front-end checks truthiness per entry
+                expandableData.push(undefined);
+                continue;
+            }
+            // Reconstruct item object only for matched rows
+            let item;
+            if (isColumnar) {
+                item = {};
+                for (let c = 0; c < targetColumns.length; c++) {
+                    item[targetColumns[c]] = targetRows[i][c];
+                }
+            }
+            else {
+                item = { ...targetObjects[i] };
+            }
+            expandableData.push({
+                item,
+                result: { success: true, sections: this.groupBatchRowIntoSections(matched) },
+            });
+        }
+        return expandableData;
+    }
+    /**
+     * Group a batch row into named sections for the expandable UI.
+     * Uses a declarative registry for JSON columns + imperative handlers for scalar fields.
+     */
+    groupBatchRowIntoSections(row) {
+        const sections = {};
+        // ── Declarative JSON column registry ─────────────────────────────────
+        // Each entry maps a JSON column name → { key, title, transform }.
+        // The transform receives the parsed array and returns formatted data rows.
+        const jsonSectionRegistry = [
+            // --- Per-frame sections (from batch_frame_root_cause) ---
+            {
+                column: 'cpu_freq_clusters_json',
+                key: 'CPU 频率',
+                title: 'CPU 频率 (Prime / Big / Little)',
+                transform: (items) => items.map((c) => ({
+                    核心类型: c.core_type,
+                    平均频率: (c.avg_mhz / 1000).toFixed(2) + 'GHz',
+                    最高频率: (c.max_mhz / 1000).toFixed(2) + 'GHz',
+                    最低频率: (c.min_mhz / 1000).toFixed(2) + 'GHz',
+                })),
+            },
+            {
+                column: 'freq_timeline_json',
+                key: 'CPU 频率变化',
+                title: '各 CPU 频率变化时间线',
+                transform: (items) => items.map((e) => ({
+                    相对时间: e.relative_ms + 'ms',
+                    CPU: e.cpu,
+                    核心类型: e.core_type,
+                    频率: e.freq_ghz + 'GHz',
+                    变化: e.change === 'up' ? '↑升频' : e.change === 'down' ? '↓降频' : '初始',
+                })),
+            },
+            {
+                column: 'main_slices_json',
+                key: '主线程耗时操作',
+                title: '主线程耗时操作 (Top 8)',
+                transform: (items) => items.map((s) => ({
+                    操作: s.name, 总耗时: s.total_ms + 'ms', 次数: s.count, 最大耗时: s.max_ms + 'ms',
+                })),
+            },
+            {
+                column: 'render_slices_json',
+                key: 'RenderThread 耗时操作',
+                title: 'RenderThread 耗时操作 (Top 8)',
+                transform: (items) => items.map((s) => ({
+                    操作: s.name, 总耗时: s.total_ms + 'ms', 次数: s.count, 最大耗时: s.max_ms + 'ms',
+                })),
+            },
+            {
+                column: 'binder_calls_json',
+                key: 'Binder 调用详情',
+                title: 'Binder 调用（按耗时降序）',
+                transform: (items) => items.map((b) => ({
+                    目标进程: b.server, 调用次数: b.count, 总耗时: b.dur_ms + 'ms', 最大耗时: b.max_ms + 'ms',
+                })),
+            },
+            {
+                column: 'gc_events_json',
+                key: 'GC 事件详情',
+                title: 'GC 事件（按类型聚合）',
+                transform: (items) => items.map((g) => ({
+                    类型: g.gc_type, 次数: g.count, 总耗时: g.total_ms + 'ms', 帧重叠: g.overlap_ms + 'ms',
+                })),
+            },
+            {
+                column: 'lock_contention_json',
+                key: '锁竞争详情',
+                title: '锁竞争（按等待时间降序）',
+                transform: (items) => items.map((l) => ({
+                    阻塞方法: l.method, 阻塞线程: l.blocker, 等待: l.wait_ms + 'ms',
+                    主线程阻塞: l.main_blocked ? '是' : '否',
+                })),
+            },
+            // --- Per-session sections (from session_stats_batch) ---
+            {
+                column: 'quadrant_json',
+                key: '四象限分布',
+                title: '滑动区间四象限分布 (Q1大核运行/Q2小核运行/Q3调度等待/Q4a IO阻塞/Q4b 休眠)',
+                transform: (items) => items.map((q) => ({
+                    线程: q.thread,
+                    'Q1 大核%': q.q1_big_pct + '%',
+                    'Q2 小核%': q.q2_little_pct + '%',
+                    'Q3 调度%': q.q3_runnable_pct + '%',
+                    'Q4a IO%': q.q4a_io_pct + '%',
+                    'Q4b 休眠%': q.q4b_sleep_pct + '%',
+                    '总时间': q.total_ms + 'ms',
+                })),
+            },
+            {
+                column: 'cpu_freq_json',
+                key: 'CPU 频率统计',
+                title: '滑动区间 CPU 频率',
+                transform: (items) => items.map((f) => ({
+                    核心类型: f.core_type,
+                    核心数: f.num_cores,
+                    '均频(MHz)': f.avg_freq_mhz,
+                    '最高频(MHz)': f.max_freq_mhz,
+                    '最低频(MHz)': f.min_freq_mhz,
+                })),
+            },
+            {
+                column: 'core_affinity_json',
+                key: '大小核分布',
+                title: '滑动区间关键线程大小核分布',
+                transform: (items) => items.map((a) => ({
+                    线程: a.thread_name,
+                    核心类型: a.core_type,
+                    '运行时间(ms)': a.run_ms,
+                    '占比%': a.pct + '%',
+                })),
+            },
+        ];
+        // ── Scalar field sections (per-frame only) ───────────────────────────
+        // Section: Root cause diagnosis
+        const diagnosisFields = ['reason_code', 'primary_cause', 'confidence', 'top_slice_name', 'top_slice_ms'];
+        const diagnosisData = {};
+        for (const f of diagnosisFields) {
+            if (row[f] != null)
+                diagnosisData[f] = row[f];
+        }
+        if (Object.keys(diagnosisData).length > 0) {
+            sections['根因诊断'] = { title: '根因诊断', data: [diagnosisData] };
+        }
+        // Section: MainThread quadrant (scalar fields)
+        const mainFields = ['main_q1_pct', 'main_q2_pct', 'main_q3_pct', 'main_q4a_pct', 'main_q4b_pct'];
+        const mainData = {};
+        let hasMainData = false;
+        for (const f of mainFields) {
+            if (row[f] != null) {
+                mainData[f.replace('main_', '').replace('_pct', '%')] = row[f] + '%';
+                hasMainData = true;
+            }
+        }
+        if (hasMainData) {
+            sections['主线程四象限'] = { title: '主线程四象限 (Q1大核运行/Q2小核运行/Q3调度等待/Q4a IO阻塞/Q4b 锁等待)', data: [mainData] };
+        }
+        // Section: RenderThread quadrant (scalar fields)
+        const renderFields = ['render_q1_pct', 'render_q2_pct', 'render_q3_pct', 'render_q4a_pct', 'render_q4b_pct'];
+        const renderData = {};
+        let hasRenderData = false;
+        for (const f of renderFields) {
+            if (row[f] != null) {
+                renderData[f.replace('render_', 'RT_').replace('_pct', '%')] = row[f] + '%';
+                hasRenderData = true;
+            }
+        }
+        if (hasRenderData) {
+            sections['渲染线程四象限'] = { title: '渲染线程四象限 (Q1大核运行/Q2小核运行/Q3调度等待/Q4a IO阻塞/Q4b 锁等待)', data: [renderData] };
+        }
+        // Section: CPU frequency fallback (scalar, when cpu_freq_clusters_json is absent)
+        if (!row['cpu_freq_clusters_json'] || row['cpu_freq_clusters_json'] === '[]') {
+            const cpuData = {};
+            let hasCpuData = false;
+            for (const f of ['big_avg_freq_mhz', 'big_max_freq_mhz', 'ramp_ms']) {
+                if (row[f] != null) {
+                    cpuData[f] = row[f];
+                    hasCpuData = true;
+                }
+            }
+            if (hasCpuData) {
+                sections['CPU 频率'] = { title: 'CPU 频率', data: [cpuData] };
+            }
+        }
+        // Section: Top Slice CPU mix
+        const cpuMixFields = ['top_slice_little_pct', 'top_slice_big_pct', 'top_slice_runnable_pct'];
+        const cpuMixData = {};
+        let hasCpuMix = false;
+        for (const f of cpuMixFields) {
+            if (row[f] != null && Number(row[f]) > 0) {
+                cpuMixData[f.replace('top_slice_', '')] = row[f] + '%';
+                hasCpuMix = true;
+            }
+        }
+        if (hasCpuMix) {
+            sections['关键操作 CPU 分布'] = { title: '关键操作 CPU 分布 (大核/小核/Runnable)', data: [cpuMixData] };
+        }
+        // Section: GPU / Shader
+        const gpuFields = ['gpu_fence_ms', 'gpu_fence_total_ms', 'shader_count', 'shader_ms'];
+        const gpuData = {};
+        let hasGpu = false;
+        for (const f of gpuFields) {
+            if (row[f] != null && Number(row[f]) > 0) {
+                gpuData[f] = row[f];
+                hasGpu = true;
+            }
+        }
+        if (hasGpu) {
+            sections['GPU / Shader'] = { title: 'GPU / Shader', data: [gpuData] };
+        }
+        // Section: Interference factors (Binder + GC)
+        const interferenceData = {};
+        let hasInterference = false;
+        if (row['binder_overlap_ms'] != null && Number(row['binder_overlap_ms']) > 0) {
+            interferenceData['binder_overlap_ms'] = row['binder_overlap_ms'];
+            hasInterference = true;
+        }
+        if (row['gc_overlap_ms'] != null && Number(row['gc_overlap_ms']) > 0) {
+            interferenceData['gc_overlap_ms'] = row['gc_overlap_ms'];
+            hasInterference = true;
+        }
+        if (row['gc_count'] != null && Number(row['gc_count']) > 0) {
+            interferenceData['gc_count'] = row['gc_count'];
+            hasInterference = true;
+        }
+        if (hasInterference) {
+            sections['干扰因素'] = { title: '干扰因素 (Binder/GC)', data: [interferenceData] };
+        }
+        // Section: Frame budget reference
+        if (row['frame_budget_ms'] != null) {
+            sections['帧预算'] = { title: '帧预算参考', data: [{ frame_budget_ms: row['frame_budget_ms'] + 'ms' }] };
+        }
+        // ── Apply JSON column registry ───────────────────────────────────────
+        for (const entry of jsonSectionRegistry) {
+            const items = this.parseJsonColumn(row, entry.column);
+            if (items.length > 0) {
+                sections[entry.key] = { title: entry.title, data: entry.transform(items) };
+            }
+        }
+        return sections;
+    }
+    /** Safely parse a JSON string column from a batch row. */
+    parseJsonColumn(row, columnName) {
+        const raw = row[columnName];
+        if (!raw || raw === '[]')
+            return [];
+        try {
+            const parsed = typeof raw === 'string' ? JSON.parse(raw) : raw;
+            return Array.isArray(parsed) ? parsed : [];
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Execute composite skill and return layered results
+     * This is an alternative execution path that organizes output by layers (overview/list/session/deep)
+     */
+    async executeCompositeSkill(skill, inputs, context) {
+        const startTime = Date.now();
+        // Validate input
+        if (!skill) {
+            throw new Error('Skill definition is required');
+        }
+        if (!skill.steps || skill.steps.length === 0) {
+            return {
+                layers: {
+                    overview: {}, list: {}, session: {}, deep: {}, diagnosis: {},
+                },
+                defaultExpanded: ['overview', 'list'],
+                stepResults: [],
+                metadata: {
+                    skillName: skill.name,
+                    version: skill.version || '1.0.0',
+                    executedAt: new Date().toISOString()
+                }
+            };
+        }
+        const traceId = context.traceId || '';
+        const gate = await this.applyIdentityGate(skill, traceId, inputs, context.inherited || {});
+        if (!gate.allowed) {
+            throw new Error(gate.error || `Process identity gate blocked skill: ${skill.name}`);
+        }
+        const prerequisiteModules = this.resolvePrerequisiteModules(skill.prerequisites?.modules);
+        const validated = (0, skillValidator_1.validateSkillInputs)(skill.name, skill.inputs, gate.params);
+        for (const w of validated.warnings) {
+            logger_1.default.warn('SkillExecutor', `[${skill.name}] ${w.paramName}: ${w.message}`);
+        }
+        if (validated.errors.length > 0) {
+            const msg = validated.errors.map(e => `${e.paramName}: ${e.message}`).join('; ');
+            logger_1.default.error('SkillExecutor', `[${skill.name}] Input validation failed: ${msg}`);
+            throw new Error(`Input validation failed: ${msg}`);
+        }
+        // Create execution context
+        const execContext = {
+            traceId,
+            params: validated.params,
+            inherited: gate.inherited,
+            results: {},
+            variables: {},
+            moduleIncludes: prerequisiteModules,
+        };
+        if (execContext.traceId && prerequisiteModules.length > 0) {
+            execContext.moduleIncludes = await this.resolveAvailableModules(execContext.traceId, prerequisiteModules);
+        }
+        // Execute all steps and collect synthesize-marked data
+        const stepResults = [];
+        const synthesizeData = [];
+        if (skill.steps) {
+            for (let i = 0; i < skill.steps.length; i++) {
+                const step = skill.steps[i];
+                const stepResult = await this.executeStep(step, execContext, skill.name);
+                // Save result to context
+                if (stepResult.success) {
+                    execContext.results[step.id] = stepResult;
+                    // Save to variables if save_as is specified
+                    if ('save_as' in step && step.save_as) {
+                        execContext.variables[step.save_as] = this.extractSaveAsValue(stepResult);
+                    }
+                }
+                // IMPORTANT: Add display config from step definition to stepResult
+                // This is needed for organizeByLayer to correctly place results in layers
+                // Process display config with template variable substitution (e.g., ${frame_id})
+                if ('display' in step && typeof step.display === 'object') {
+                    stepResult.display = processDisplayConfig(step.display, execContext);
+                }
+                // 收集标记为 synthesize 的步骤数据
+                // 支持两种格式：
+                // 1. synthesize: true (旧格式，向后兼容)
+                // 2. synthesize: { role: ..., fields: ... } (新格式，数据驱动)
+                if ('synthesize' in step && step.synthesize) {
+                    const synthesizeValue = step.synthesize;
+                    const displayConfig = step.display && typeof step.display === 'object' ? step.display : {};
+                    // 解析 synthesize 配置
+                    let config;
+                    if (typeof synthesizeValue === 'object' && synthesizeValue.role) {
+                        // 新格式：完整的配置对象
+                        config = synthesizeValue;
+                    }
+                    // 旧格式 (synthesize: true) 不设置 config，由 analysisWorker 使用默认处理
+                    synthesizeData.push({
+                        stepId: step.id,
+                        stepName: ('name' in step ? step.name : step.id) || step.id,
+                        stepType: typeof step.type === 'string' ? step.type : 'skill',
+                        layer: displayConfig.layer,
+                        data: stepResult.data,
+                        success: stepResult.success,
+                        config, // 包含 YAML 中定义的配置（如果有）
+                    });
+                }
+                stepResults.push(stepResult);
+            }
+        }
+        // Iterator 结果绑回源列表：将 expandableData 绑定到 source step 的 StepResult
+        // 这样 convertDisplayResultsToSections 可以在源步骤的 data 上找到 expandableData
+        if (skill.steps) {
+            for (let i = 0; i < skill.steps.length; i++) {
+                const step = skill.steps[i];
+                if (step.type === 'iterator' && 'source' in step && step.source) {
+                    const sourceName = step.source;
+                    // source 引用的是 save_as 名称，需要找到对应的 step.id
+                    const sourceStep = skill.steps.find((s) => s.save_as === sourceName || s.id === sourceName);
+                    const sourceStepId = sourceStep ? sourceStep.id : sourceName;
+                    const sourceResult = stepResults.find(sr => sr.stepId === sourceStepId);
+                    const iteratorResult = stepResults[i];
+                    // 在 executeCompositeSkill 路径中，iterator 的 data 是原始 [{itemIndex, item, result}, ...]
+                    // 需要将其转换为 expandableData 格式
+                    if (sourceResult?.data && iteratorResult?.success && Array.isArray(iteratorResult.data)) {
+                        const expandableData = iteratorResult.data.map((iterItem) => ({
+                            item: iterItem.item,
+                            result: {
+                                success: iterItem.result?.success ?? false,
+                                sections: this.convertDisplayResultsToSections(iterItem.result?.displayResults || []),
+                                error: iterItem.result?.error,
+                            },
+                        }));
+                        // 直接在 data 上挂载 expandableData（JS 数组/对象都支持额外属性）
+                        sourceResult.data.expandableData = expandableData;
+                    }
+                }
+            }
+        }
+        // Batch-to-expandable binding for executeCompositeSkill path (object-array variant)
+        if (skill.steps) {
+            for (const step of skill.steps) {
+                const display = step.display && typeof step.display === 'object' ? step.display : undefined;
+                const bindSource = display?.expandableBindSource;
+                if (!bindSource)
+                    continue;
+                const sourceData = execContext.variables[bindSource];
+                const targetResult = stepResults.find(sr => sr.stepId === step.id);
+                if (!Array.isArray(sourceData) || sourceData.length === 0)
+                    continue;
+                if (!targetResult?.data || !Array.isArray(targetResult.data) || targetResult.data.length === 0)
+                    continue;
+                if (typeof targetResult.data[0] !== 'object' || targetResult.data[0] === null)
+                    continue;
+                const expandableData = this.buildExpandableFromBatch(null, null, sourceData, targetResult.data);
+                targetResult.data.expandableData = expandableData;
+            }
+        }
+        // Return layered structure
+        try {
+            const layers = organizeByLayer(stepResults);
+            const result = {
+                layers,
+                defaultExpanded: ['overview', 'list'],
+                metadata: {
+                    skillName: skill.name,
+                    version: skill.version || '1.0.0',
+                    executedAt: new Date().toISOString()
+                },
+                stepResults,
+                // 添加收集的 synthesize 数据
+                synthesizeData: synthesizeData.length > 0 ? synthesizeData : undefined,
+            };
+            // synthesizeData collected for final summary (debug logging removed)
+            return result;
+        }
+        catch (error) {
+            console.error('[executeCompositeSkill] organizeByLayer failed:', error);
+            throw error;
+        }
+    }
+    /**
+     * 执行原子 skill（单个 SQL）
+     */
+    async executeAtomicSkill(skill, context) {
+        const startTime = Date.now();
+        if (!skill.sql) {
+            return {
+                stepId: 'root',
+                stepType: 'atomic',
+                success: false,
+                error: 'No SQL defined for atomic skill',
+                executionTimeMs: Date.now() - startTime,
+            };
+        }
+        const sql = this.buildSqlWithModuleIncludes(substituteVariables(skill.sql, context), context);
+        try {
+            const result = await this.traceProcessor.query(context.traceId, sql);
+            if (result.error) {
+                return {
+                    stepId: 'root',
+                    stepType: 'atomic',
+                    success: false,
+                    error: result.error,
+                    executionTimeMs: Date.now() - startTime,
+                };
+            }
+            return {
+                stepId: 'root',
+                stepType: 'atomic',
+                success: true,
+                data: this.rowsToObjects(result.columns, result.rows),
+                executionTimeMs: Date.now() - startTime,
+                display: skill.output?.display ? processDisplayConfig(skill.output.display, context) : undefined,
+            };
+        }
+        catch (error) {
+            return {
+                stepId: 'root',
+                stepType: 'atomic',
+                success: false,
+                error: error.message,
+                executionTimeMs: Date.now() - startTime,
+            };
+        }
+    }
+    /**
+     * 执行单个步骤
+     */
+    async executeStep(step, context, parentSkillId) {
+        const startTime = Date.now();
+        // 检查步骤的条件限制
+        if ('condition' in step && typeof step.condition === 'string') {
+            const conditionStr = step.condition;
+            const conditionResult = ExpressionEvaluator.evaluateCondition(conditionStr, context);
+            if (!conditionResult) {
+                const isOptional = Boolean(step.optional);
+                this.emit({
+                    type: 'step_completed',
+                    skillId: parentSkillId,
+                    stepId: step.id,
+                    data: { skipped: true, reason: 'condition_not_met', optional: isOptional },
+                });
+                return {
+                    stepId: step.id,
+                    stepType: step.type,
+                    success: isOptional,
+                    data: isOptional ? [] : undefined,
+                    error: isOptional ? undefined : 'Condition not met',
+                    executionTimeMs: Date.now() - startTime,
+                };
+            }
+        }
+        this.emit({
+            type: 'step_started',
+            skillId: parentSkillId,
+            stepId: step.id,
+            data: { stepType: step.type },
+        });
+        let result;
+        try {
+            switch (step.type) {
+                case 'atomic':
+                    result = await this.executeAtomicStep(step, context);
+                    break;
+                case 'iterator':
+                    result = await this.executeIteratorStep(step, context, parentSkillId);
+                    break;
+                case 'parallel':
+                    result = await this.executeParallelStep(step, context, parentSkillId);
+                    break;
+                case 'diagnostic':
+                    result = await this.executeDiagnosticStep(step, context);
+                    break;
+                case 'ai_decision':
+                    result = await this.executeAIDecisionStep(step, context);
+                    break;
+                case 'ai_summary':
+                    result = await this.executeAISummaryStep(step, context);
+                    break;
+                case 'conditional':
+                    result = await this.executeConditionalStep(step, context, parentSkillId);
+                    break;
+                case 'pipeline':
+                    result = await this.executePipelineStep(step, context);
+                    break;
+                default:
+                    // 默认作为 skill 引用处理
+                    const unknownStep = step;
+                    if ('skill' in unknownStep) {
+                        result = await this.executeSkillRefStep(unknownStep, context);
+                    }
+                    else {
+                        result = {
+                            stepId: unknownStep.id,
+                            stepType: 'atomic',
+                            success: false,
+                            error: `Unknown step type: ${unknownStep.type}`,
+                            executionTimeMs: Date.now() - startTime,
+                        };
+                    }
+            }
+        }
+        catch (error) {
+            const failedStep = step;
+            result = {
+                stepId: failedStep.id,
+                stepType: failedStep.type || 'skill',
+                success: false,
+                error: error.message,
+                executionTimeMs: Date.now() - startTime,
+            };
+        }
+        this.emit({
+            type: 'step_completed',
+            skillId: parentSkillId,
+            stepId: step.id,
+            data: { success: result.success, error: result.error },
+        });
+        return result;
+    }
+    /**
+     * 执行原子步骤
+     */
+    async executeAtomicStep(step, context) {
+        const startTime = Date.now();
+        let substitutedSql = substituteVariables(step.sql, context);
+        // Inject SQL fragments if declared on this step
+        if (step.sql_fragments?.length) {
+            substitutedSql = this.injectSqlFragments(substitutedSql, step.sql_fragments, context);
+        }
+        const sql = this.buildSqlWithModuleIncludes(substitutedSql, context);
+        try {
+            const result = await this.traceProcessor.query(context.traceId, sql);
+            if (result.error) {
+                if (step.optional) {
+                    return {
+                        stepId: step.id,
+                        stepType: 'atomic',
+                        success: true,
+                        data: [],
+                        executionTimeMs: Date.now() - startTime,
+                    };
+                }
+                return {
+                    stepId: step.id,
+                    stepType: 'atomic',
+                    success: false,
+                    error: result.error,
+                    executionTimeMs: Date.now() - startTime,
+                };
+            }
+            const data = this.rowsToObjects(result.columns, result.rows);
+            return {
+                stepId: step.id,
+                stepType: 'atomic',
+                success: true,
+                data,
+                executionTimeMs: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            if (step.optional) {
+                return {
+                    stepId: step.id,
+                    stepType: 'atomic',
+                    success: true,
+                    data: [],
+                    executionTimeMs: Date.now() - startTime,
+                };
+            }
+            throw error;
+        }
+    }
+    /**
+     * 检查 prerequisites 条件 (required_tables, optional_tables)
+     */
+    async checkPrerequisites(skill, traceId) {
+        if (!skill.prerequisites)
+            return { success: true };
+        const { required_tables } = skill.prerequisites;
+        if (!required_tables || required_tables.length === 0) {
+            return { success: true };
+        }
+        try {
+            // Perfetto trace_processor uses virtual tables that may not appear in sqlite_master.
+            // These core tables are ALWAYS present in any valid Perfetto trace:
+            const CORE_TABLES = new Set(['thread', 'process', 'slice', 'counter', 'track', 'thread_track', 'counter_track']);
+            // Filter out core tables - they're guaranteed to exist
+            const tablesToCheck = required_tables.filter(t => !CORE_TABLES.has(t));
+            if (tablesToCheck.length === 0) {
+                // All required tables are core tables - they always exist
+                return { success: true };
+            }
+            // For non-core tables, query sqlite_master (include views for Perfetto's virtual tables)
+            const tableList = tablesToCheck.map(t => `'${t}'`).join(',');
+            const query = `
+        SELECT name
+        FROM sqlite_master
+        WHERE type IN ('table', 'view') AND name IN (${tableList})
+      `;
+            const result = await this.traceProcessor.query(traceId, query);
+            const existingTables = new Set();
+            // 处理查询结果（兼容多种返回结构）
+            if (result) {
+                if (result.columns && Array.isArray(result.rows)) {
+                    const nameIdx = result.columns.indexOf('name');
+                    if (nameIdx >= 0) {
+                        for (const row of result.rows) {
+                            if (Array.isArray(row) && row[nameIdx]) {
+                                existingTables.add(String(row[nameIdx]));
+                            }
+                            else if (row && typeof row === 'object' && row['name']) {
+                                existingTables.add(String(row['name']));
+                            }
+                        }
+                    }
+                }
+                else if (Array.isArray(result)) {
+                    result.forEach((row) => {
+                        if (row?.name) {
+                            existingTables.add(String(row.name));
+                        }
+                    });
+                }
+            }
+            // 检查缺少的表 (only check non-core tables)
+            const missingTables = tablesToCheck.filter(t => !existingTables.has(t));
+            if (missingTables.length > 0) {
+                return {
+                    success: false,
+                    error: `Trace is missing required tables: ${missingTables.join(', ')}`
+                };
+            }
+            return { success: true };
+        }
+        catch (e) {
+            console.error(`[SkillExecutor] Failed to check prerequisites: ${e.message}`);
+            //为了健壮性，查询失败时不阻止执行，可能是 traceProcessor 问题
+            return { success: true };
+        }
+    }
+    /**
+     * 执行 skill 引用步骤
+     */
+    async executeSkillRefStep(step, context) {
+        const startTime = Date.now();
+        // 构建子 skill 的参数
+        const params = {};
+        if (step.params) {
+            for (const [key, value] of Object.entries(step.params)) {
+                if (typeof value === 'string' && value.startsWith('${')) {
+                    params[key] = ExpressionEvaluator.evaluate(value, context);
+                }
+                else {
+                    params[key] = value;
+                }
+            }
+        }
+        // 执行子 skill
+        const result = await this.execute(step.skill, context.traceId, params, { ...context.inherited, ...context.variables });
+        return {
+            stepId: step.id,
+            stepType: 'skill',
+            success: result.success,
+            data: result,
+            error: result.error,
+            executionTimeMs: Date.now() - startTime,
+        };
+    }
+    /**
+     * 执行迭代步骤
+     */
+    async executeIteratorStep(step, context, parentSkillId) {
+        const startTime = Date.now();
+        const itemSkillName = typeof step.item_skill === 'string'
+            ? String(step.item_skill)
+            : (typeof step.skill === 'string' ? String(step.skill) : '');
+        if (!itemSkillName) {
+            return {
+                stepId: step.id,
+                stepType: 'iterator',
+                success: false,
+                error: `Iterator item_skill is missing: ${step.id}`,
+                executionTimeMs: Date.now() - startTime,
+            };
+        }
+        // 获取数据源
+        const source = context.variables[step.source] || context.results[step.source]?.data;
+        if (!source || !Array.isArray(source)) {
+            return {
+                stepId: step.id,
+                stepType: 'iterator',
+                success: false,
+                error: `Iterator source not found or not an array: ${step.source}`,
+                executionTimeMs: Date.now() - startTime,
+            };
+        }
+        const results = [];
+        const maxItems = step.max_items || 100; // 性能保护
+        let items = [...source];
+        // Optional iterator filter (best-effort): allows skills to analyze only a subset of items.
+        // Example in YAML: filter: "jank_level == 'severe' OR jank_level == 'bad'"
+        const filterExprRaw = typeof step.filter === 'string' ? String(step.filter).trim() : '';
+        if (filterExprRaw) {
+            const filterExpr = filterExprRaw
+                .replace(/\bOR\b/gi, '||')
+                .replace(/\bAND\b/gi, '&&');
+            try {
+                items = items.filter((item) => {
+                    const itemObj = (item && typeof item === 'object') ? item : {};
+                    const filterCtx = {
+                        ...context,
+                        // Expose item fields at root-level for convenience in filter expressions.
+                        inherited: { ...(context.inherited || {}), ...itemObj },
+                        currentItem: itemObj,
+                    };
+                    return ExpressionEvaluator.evaluateCondition(filterExpr, filterCtx);
+                });
+            }
+            catch {
+                // Ignore filter evaluation errors (iterator still runs).
+            }
+        }
+        items = items.slice(0, maxItems);
+        for (let i = 0; i < items.length; i++) {
+            const item = items[i];
+            // 构建子 skill 的参数
+            const params = {};
+            if (step.item_params) {
+                for (const [key, path] of Object.entries(step.item_params)) {
+                    // 仅在字段不存在(=== undefined)时才回退为常量字符串；保留 null（常用于 SQL NULL）
+                    const v = item?.[path];
+                    params[key] = v !== undefined ? v : path;
+                }
+            }
+            else {
+                // 默认将 item 的所有字段作为参数
+                Object.assign(params, item);
+            }
+            // 设置当前迭代项
+            const iterContext = { ...context };
+            iterContext.currentItem = item;
+            iterContext.currentItemIndex = i;
+            // 执行子 skill
+            const itemResult = await this.execute(itemSkillName, context.traceId, params, { ...context.inherited, ...context.variables, item });
+            // Always record the per-item result, even if it failed (so UI/Agents can see errors).
+            results.push({
+                itemIndex: i,
+                item,
+                result: itemResult,
+            });
+        }
+        return {
+            stepId: step.id,
+            stepType: 'iterator',
+            success: true,
+            data: results,
+            executionTimeMs: Date.now() - startTime,
+        };
+    }
+    /**
+     * 执行并行步骤
+     */
+    async executeParallelStep(step, context, parentSkillId) {
+        const startTime = Date.now();
+        const promises = step.steps.map(subStep => this.executeStep(subStep, context, parentSkillId));
+        const results = await Promise.all(promises);
+        const allSuccess = results.every(r => r.success);
+        // 将结果存入 context
+        const data = {};
+        for (let i = 0; i < step.steps.length; i++) {
+            const subStep = step.steps[i];
+            data[subStep.id] = results[i].data;
+            context.results[subStep.id] = results[i];
+        }
+        return {
+            stepId: step.id,
+            stepType: 'parallel',
+            success: allSuccess,
+            data,
+            executionTimeMs: Date.now() - startTime,
+        };
+    }
+    /**
+     * 执行诊断步骤
+     */
+    async executeDiagnosticStep(step, context) {
+        const startTime = Date.now();
+        const diagnostics = [];
+        // 收集输入数据
+        const inputs = {};
+        for (const inputName of step.inputs) {
+            inputs[inputName] = context.variables[inputName] || context.results[inputName]?.data;
+        }
+        // 评估规则
+        for (const rule of step.rules) {
+            const conditionResult = ExpressionEvaluator.evaluateCondition(rule.condition, context);
+            if (conditionResult) {
+                const confidence = typeof rule.confidence === 'number'
+                    ? rule.confidence
+                    : rule.confidence === 'high' ? 0.9 : rule.confidence === 'medium' ? 0.7 : 0.5;
+                const severityFromRule = rule.severity === 'critical' || rule.severity === 'warning' || rule.severity === 'info'
+                    ? rule.severity
+                    : undefined;
+                // Substitute variables in diagnosis message
+                const diagnosis = ExpressionEvaluator.evaluate(rule.diagnosis, context);
+                // 收集 evidence 数据
+                const evidence = this.collectDiagnosticEvidence(rule, context, inputs);
+                // Evaluate suggestions templates (e.g., "${root_cause.data[0].secondary_info}")
+                const evaluatedSuggestions = rule.suggestions?.map((s) => typeof s === 'string' ? ExpressionEvaluator.evaluate(s, context) : s);
+                diagnostics.push({
+                    id: `${step.id}_${diagnostics.length}`,
+                    diagnosis,
+                    confidence,
+                    severity: severityFromRule ?? (confidence >= 0.8 ? 'critical' : confidence >= 0.6 ? 'warning' : 'info'),
+                    suggestions: evaluatedSuggestions,
+                    evidence,
+                    source: 'rule',
+                });
+            }
+        }
+        // 如果没有匹配的规则且配置了 AI 辅助，调用 AI
+        if (diagnostics.length === 0 && step.ai_assist && step.fallback && this.aiService) {
+            const aiResult = await this.callAI(step.fallback.prompt, context);
+            if (aiResult) {
+                diagnostics.push({
+                    id: `${step.id}_ai`,
+                    diagnosis: aiResult,
+                    confidence: 0.6,
+                    severity: 'info',
+                    source: 'ai',
+                });
+            }
+        }
+        return {
+            stepId: step.id,
+            stepType: 'diagnostic',
+            success: true,
+            data: { diagnostics, inputs },
+            executionTimeMs: Date.now() - startTime,
+        };
+    }
+    /**
+     * 收集诊断结论的数据依据
+     * 从 rule.evidence_fields 或自动从 condition 解析引用的数据源
+     */
+    collectDiagnosticEvidence(rule, context, inputs) {
+        const evidence = {};
+        // 1. 如果规则定义了 evidence_fields，使用它们
+        if (rule.evidence_fields && Array.isArray(rule.evidence_fields)) {
+            for (const field of rule.evidence_fields) {
+                const value = this.resolveEvidenceField(field, context, inputs);
+                if (value !== undefined) {
+                    evidence[field] = value;
+                }
+            }
+        }
+        // 2. 自动从 condition 中提取数据源引用
+        const conditionSources = this.extractDataSources(rule.condition);
+        for (const source of conditionSources) {
+            // 只提取第一行数据作为 evidence（避免数据过大）
+            const sourceData = inputs[source];
+            if (sourceData && !evidence[source]) {
+                if (Array.isArray(sourceData) && sourceData.length > 0) {
+                    // 只取第一条记录的关键字段
+                    const firstRow = sourceData[0];
+                    evidence[source] = {
+                        _summary: `共 ${sourceData.length} 条记录`,
+                        _firstRow: this.extractKeyFields(firstRow),
+                    };
+                }
+                else if (typeof sourceData === 'object') {
+                    evidence[source] = this.extractKeyFields(sourceData);
+                }
+            }
+        }
+        // 3. 添加时间戳用于 Perfetto 跳转
+        const tsField = this.findTimestampField(inputs, conditionSources);
+        if (tsField) {
+            evidence._perfettoTs = tsField;
+        }
+        return Object.keys(evidence).length > 0 ? evidence : undefined;
+    }
+    /**
+     * 从表达式中提取数据源名称
+     * 例如: "lock_data.data[0]?.wait_ms > 2" => ["lock_data"]
+     */
+    extractDataSources(expression) {
+        const sources = new Set();
+        // 匹配 xxx.data 或 xxx.xxx 形式的数据源引用
+        const matches = expression.match(/(\w+)\.data/g);
+        if (matches) {
+            for (const match of matches) {
+                const source = match.replace('.data', '');
+                sources.add(source);
+            }
+        }
+        return Array.from(sources);
+    }
+    /**
+     * 解析 evidence_fields 中的字段路径
+     * 支持格式: "source.field" 或 "source.data[0].field"
+     */
+    resolveEvidenceField(field, context, inputs) {
+        try {
+            // 尝试从 inputs 中解析
+            const parts = field.split('.');
+            let value = inputs;
+            for (const part of parts) {
+                if (value === undefined)
+                    return undefined;
+                // 处理数组索引，如 data[0]
+                const arrayMatch = part.match(/^(\w+)\[(\d+)\]$/);
+                if (arrayMatch) {
+                    value = value[arrayMatch[1]]?.[parseInt(arrayMatch[2])];
+                }
+                else {
+                    value = value[part];
+                }
+            }
+            return value;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * 从对象中提取关键字段（排除大型嵌套对象）
+     */
+    extractKeyFields(obj) {
+        if (!obj || typeof obj !== 'object')
+            return obj;
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            // 跳过大型数组和深层嵌套对象
+            if (Array.isArray(value)) {
+                result[key] = `[Array(${value.length})]`;
+            }
+            else if (value && typeof value === 'object') {
+                // 只保留一层深度
+                result[key] = '[Object]';
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    /**
+     * 从输入数据中找到时间戳字段用于 Perfetto 跳转
+     */
+    findTimestampField(inputs, sources) {
+        for (const source of sources) {
+            const data = inputs[source];
+            if (Array.isArray(data) && data.length > 0) {
+                const firstRow = data[0];
+                // 常见的时间戳字段名
+                const tsFields = ['ts', 'start_ts', 'timestamp', 'begin_ts'];
+                for (const field of tsFields) {
+                    if (firstRow[field] !== undefined && firstRow[field] !== null) {
+                        return String(firstRow[field]);
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * 执行 AI 决策步骤
+     */
+    async executeAIDecisionStep(step, context) {
+        const startTime = Date.now();
+        if (!this.aiService) {
+            return {
+                stepId: step.id,
+                stepType: 'ai_decision',
+                success: false,
+                error: 'AI service not available',
+                executionTimeMs: Date.now() - startTime,
+            };
+        }
+        const basePrompt = ExpressionEvaluator.evaluate(step.prompt, context);
+        const inputsPayloadRaw = this.buildAIInputsPayload(step.inputs, context);
+        const inputsPayload = inputsPayloadRaw ? (0, llmPrivacy_1.redactObjectForLLM)(inputsPayloadRaw).value : null;
+        const promptRaw = this.buildStructuredAIPrompt(basePrompt, inputsPayload, 'decision');
+        const prompt = (0, llmPrivacy_1.redactTextForLLM)(promptRaw).text;
+        this.emit({
+            type: 'ai_thinking',
+            skillId: '',
+            stepId: step.id,
+            data: { prompt },
+        });
+        const response = await this.callAI(prompt, context, 'evaluation');
+        const normalizedDecision = this.extractStructuredAIField(response, 'decision');
+        this.emit({
+            type: 'ai_response',
+            skillId: '',
+            stepId: step.id,
+            data: { response: normalizedDecision, rawResponse: response },
+        });
+        return {
+            stepId: step.id,
+            stepType: 'ai_decision',
+            success: true,
+            data: { decision: normalizedDecision },
+            executionTimeMs: Date.now() - startTime,
+        };
+    }
+    /**
+     * 执行 AI 总结步骤
+     */
+    async executeAISummaryStep(step, context) {
+        const startTime = Date.now();
+        if (!this.aiService) {
+            return {
+                stepId: step.id,
+                stepType: 'ai_summary',
+                success: false,
+                error: 'AI service not available',
+                executionTimeMs: Date.now() - startTime,
+            };
+        }
+        const basePrompt = ExpressionEvaluator.evaluate(step.prompt, context);
+        const inputsPayloadRaw = this.buildAIInputsPayload(step.inputs, context);
+        const inputsPayload = inputsPayloadRaw ? (0, llmPrivacy_1.redactObjectForLLM)(inputsPayloadRaw).value : null;
+        const promptRaw = this.buildStructuredAIPrompt(basePrompt, inputsPayload, 'summary');
+        const prompt = (0, llmPrivacy_1.redactTextForLLM)(promptRaw).text;
+        this.emit({
+            type: 'ai_thinking',
+            skillId: '',
+            stepId: step.id,
+            data: { prompt },
+        });
+        const response = await this.callAI(prompt, context, 'synthesis');
+        const normalizedSummary = this.extractStructuredAIField(response, 'summary');
+        this.emit({
+            type: 'ai_response',
+            skillId: '',
+            stepId: step.id,
+            data: { response: normalizedSummary, rawResponse: response },
+        });
+        return {
+            stepId: step.id,
+            stepType: 'ai_summary',
+            success: true,
+            data: { summary: normalizedSummary },
+            executionTimeMs: Date.now() - startTime,
+        };
+    }
+    /**
+     * 执行条件步骤
+     */
+    async executeConditionalStep(step, context, parentSkillId) {
+        const startTime = Date.now();
+        // 评估条件
+        for (const condition of step.conditions) {
+            if (ExpressionEvaluator.evaluateCondition(condition.when, context)) {
+                if (typeof condition.then === 'string') {
+                    // skill 引用
+                    return this.executeSkillRefStep({
+                        id: step.id,
+                        skill: condition.then,
+                    }, context);
+                }
+                else {
+                    // 内联步骤
+                    return this.executeStep(condition.then, context, parentSkillId);
+                }
+            }
+        }
+        // 默认分支
+        if (step.else) {
+            if (typeof step.else === 'string') {
+                return this.executeSkillRefStep({
+                    id: step.id,
+                    skill: step.else,
+                }, context);
+            }
+            else {
+                return this.executeStep(step.else, context, parentSkillId);
+            }
+        }
+        return {
+            stepId: step.id,
+            stepType: 'conditional',
+            success: true,
+            data: null,
+            executionTimeMs: Date.now() - startTime,
+        };
+    }
+    /**
+     * 执行 pipeline 步骤
+     *
+     * 将渲染管线检测结果聚合为教学内容 + Pin 指令，作为 SkillEngine 一等步骤类型输出。
+     */
+    async executePipelineStep(step, context) {
+        const startTime = Date.now();
+        try {
+            await (0, pipelineSkillLoader_1.ensurePipelineSkillsInitialized)();
+            const pipelineSource = step.pipeline_source || 'pipeline_result';
+            const activeProcessesSource = step.active_processes_source || 'active_rendering_processes';
+            const traceRequirementsSource = step.trace_requirements_source || 'trace_requirements';
+            const pipelineRow = this.resolveFirstObjectRowFromSource(pipelineSource, context);
+            const explicitPipelineIdRaw = typeof step.pipeline_id === 'string' && step.pipeline_id.trim().length > 0
+                ? ExpressionEvaluator.evaluate(step.pipeline_id, context)
+                : undefined;
+            const explicitPipelineId = explicitPipelineIdRaw !== undefined && explicitPipelineIdRaw !== null
+                ? String(explicitPipelineIdRaw).trim()
+                : '';
+            const primaryPipelineId = (explicitPipelineId ||
+                String(pipelineRow?.primary_pipeline_id ?? '').trim() ||
+                teaching_config_1.TEACHING_DEFAULTS.pipelineId);
+            const primaryConfidence = (0, teaching_types_1.validateConfidence)(pipelineRow?.primary_confidence, teaching_config_1.TEACHING_DEFAULTS.confidence);
+            const candidatesList = pipelineRow?.candidates_list || '';
+            const featuresList = pipelineRow?.features_list || '';
+            const docPath = String(pipelineRow?.doc_path || teaching_config_1.TEACHING_DEFAULTS.docPath);
+            const candidates = candidatesList
+                ? (0, teaching_types_1.parseCandidates)(candidatesList, teaching_config_1.TEACHING_LIMITS.maxCandidates)
+                : [{ id: primaryPipelineId, confidence: primaryConfidence }];
+            const features = (0, teaching_types_1.parseFeatures)(featuresList);
+            const traceRequirementsMissing = this.extractTraceRequirementHints(this.resolveFirstObjectRowFromSource(traceRequirementsSource, context));
+            const activeRenderingProcesses = (0, teaching_types_1.validateActiveProcesses)(this.resolveStepResultFromSource(activeProcessesSource, context));
+            const yamlTeaching = pipelineSkillLoader_1.pipelineSkillLoader.getTeachingContent(primaryPipelineId);
+            const mdTeaching = (0, pipelineDocService_1.getPipelineDocService)().getTeachingContent(primaryPipelineId);
+            const teachingContent = yamlTeaching
+                ? (0, teaching_types_1.transformTeachingContent)(yamlTeaching, pipelineSkillLoader_1.pipelineSkillLoader.getPipelineMeta(primaryPipelineId)?.doc_path || docPath)
+                : mdTeaching
+                    ? {
+                        title: mdTeaching.title,
+                        summary: mdTeaching.summary,
+                        mermaidBlocks: mdTeaching.mermaidBlocks,
+                        threadRoles: mdTeaching.threadRoles,
+                        keySlices: mdTeaching.keySlices,
+                        docPath: mdTeaching.docPath,
+                    }
+                    : null;
+            const basePinInstructions = pipelineSkillLoader_1.pipelineSkillLoader
+                .getAutoPinInstructions(primaryPipelineId)
+                .slice(0, teaching_config_1.TEACHING_LIMITS.maxPinInstructions);
+            const smartFilterConfigs = pipelineSkillLoader_1.pipelineSkillLoader.getSmartFilterConfigs(primaryPipelineId);
+            const pinInstructions = basePinInstructions.map((inst) => {
+                const hasSmartFilter = inst.smart_filter?.enabled ?? smartFilterConfigs.has(inst.pattern);
+                const rawInstruction = {
+                    pattern: inst.pattern,
+                    match_by: inst.match_by,
+                    priority: inst.priority,
+                    reason: inst.reason,
+                    expand: inst.expand,
+                    main_thread_only: inst.main_thread_only,
+                    smart_filter: hasSmartFilter
+                        ? (inst.smart_filter || { enabled: true })
+                        : undefined,
+                };
+                const transformed = (0, teaching_types_1.transformPinInstruction)(rawInstruction, activeRenderingProcesses);
+                if (transformed.smartPin && !transformed.skipPin) {
+                    transformed.reason = `${inst.reason} (${activeRenderingProcesses.length} 活跃进程)`;
+                }
+                return transformed;
+            });
+            return {
+                stepId: step.id,
+                stepType: 'pipeline',
+                success: true,
+                data: {
+                    detection: {
+                        detected: !!pipelineRow || !!explicitPipelineId,
+                        primaryPipelineId,
+                        primaryConfidence,
+                        candidates,
+                        features,
+                        traceRequirementsMissing,
+                    },
+                    teachingContent,
+                    pinInstructions,
+                    activeRenderingProcesses,
+                    docPath,
+                },
+                executionTimeMs: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                stepId: step.id,
+                stepType: 'pipeline',
+                success: false,
+                error: error?.message || 'Pipeline step execution failed',
+                executionTimeMs: Date.now() - startTime,
+            };
+        }
+    }
+    resolveStepResultFromSource(source, context) {
+        if (context.results[source])
+            return context.results[source];
+        if (context.variables[source] !== undefined) {
+            return { data: context.variables[source] };
+        }
+        return undefined;
+    }
+    resolveFirstObjectRowFromSource(source, context) {
+        const sourceResult = this.resolveStepResultFromSource(source, context);
+        const sourceData = sourceResult?.data;
+        if (Array.isArray(sourceData)) {
+            const row = sourceData.find((item) => item && typeof item === 'object' && !Array.isArray(item));
+            return row ? row : null;
+        }
+        if (sourceData && typeof sourceData === 'object' && !Array.isArray(sourceData)) {
+            return sourceData;
+        }
+        return null;
+    }
+    extractTraceRequirementHints(row) {
+        if (!row)
+            return [];
+        const hints = [];
+        for (const value of Object.values(row)) {
+            if (typeof value !== 'string')
+                continue;
+            const trimmed = value.trim();
+            if (trimmed.length > 0)
+                hints.push(trimmed);
+        }
+        return hints;
+    }
+    /**
+     * 调用 AI 服务
+     */
+    async callAI(prompt, _context, taskType = 'general') {
+        if (!this.aiService) {
+            return '';
+        }
+        const safePrompt = (0, llmPrivacy_1.redactTextForLLM)(prompt).text;
+        try {
+            if (typeof this.aiService.chat === 'function') {
+                return await this.aiService.chat(safePrompt);
+            }
+            if (typeof this.aiService.callWithFallback === 'function') {
+                const result = await this.aiService.callWithFallback(safePrompt, taskType, { temperature: 0 });
+                return result?.response || result?.content || '';
+            }
+            throw new Error('AI service does not implement chat');
+        }
+        catch (error) {
+            console.error('[SkillExecutor] AI call failed:', error.message);
+            return '';
+        }
+    }
+    /**
+     * Build a compact, deterministic payload for ai_summary/ai_decision steps.
+     *
+     * Note: step.inputs uses save_as names (preferred) or step ids.
+     * We intentionally sample rows to avoid prompt bloat.
+     */
+    buildAIInputsPayload(inputs, context) {
+        if (!inputs || inputs.length === 0)
+            return null;
+        const payload = {};
+        const maxSampleRows = 5;
+        const maxColumns = 64;
+        for (const inputName of inputs) {
+            const value = this.resolveAIInputValue(inputName, context);
+            if (value === undefined) {
+                payload[inputName] = { missing: true };
+                continue;
+            }
+            if (Array.isArray(value)) {
+                const count = value.length;
+                const firstRow = count > 0 ? value[0] : undefined;
+                const columns = firstRow && typeof firstRow === 'object' && !Array.isArray(firstRow)
+                    ? Object.keys(firstRow).slice(0, maxColumns)
+                    : undefined;
+                const sample = value.slice(0, Math.min(count, maxSampleRows)).map((row) => {
+                    if (row && typeof row === 'object')
+                        return this.extractKeyFields(row);
+                    return row;
+                });
+                payload[inputName] = {
+                    type: 'array',
+                    count,
+                    columns,
+                    sample,
+                    truncated: count > maxSampleRows,
+                };
+                continue;
+            }
+            if (value && typeof value === 'object') {
+                payload[inputName] = {
+                    type: 'object',
+                    value: this.extractKeyFields(value),
+                };
+                continue;
+            }
+            payload[inputName] = {
+                type: typeof value,
+                value,
+            };
+        }
+        return payload;
+    }
+    resolveAIInputValue(inputName, context) {
+        if (context.variables[inputName] !== undefined) {
+            return context.variables[inputName];
+        }
+        if (context.results[inputName]?.data !== undefined) {
+            return context.results[inputName].data;
+        }
+        if (context.params && context.params[inputName] !== undefined) {
+            return context.params[inputName];
+        }
+        if (context.inherited && context.inherited[inputName] !== undefined) {
+            return context.inherited[inputName];
+        }
+        if (context.currentItem && context.currentItem[inputName] !== undefined) {
+            return context.currentItem[inputName];
+        }
+        return undefined;
+    }
+    buildStructuredAIPrompt(basePrompt, inputsPayload, mode) {
+        const schema = mode === 'decision'
+            ? '{"decision":"string","reasoning":"string","confidence":"high|medium|low","missing_data":["string"]}'
+            : '{"summary":"string","key_points":["string"],"confidence":"high|medium|low","missing_data":["string"],"next_steps":["string"]}';
+        const inputBlock = inputsPayload
+            ? `\n\n[INPUT_DATA_JSON]\n${JSON.stringify(inputsPayload, null, 2)}\n[/INPUT_DATA_JSON]`
+            : '';
+        const groundingRule = mode === 'decision'
+            ? '严格要求：只根据 INPUT_DATA_JSON 中提供的数据做判断；缺数据就明确说明缺口。'
+            : '严格要求：只基于 INPUT_DATA_JSON 中的实际数据分析；不要编造数值。若字段不存在/为空，请明确说明无法判断，并给出下一步建议。';
+        return `${basePrompt}${inputBlock}\n\n${groundingRule}\n输出要求：只返回一个 JSON 对象，不要输出 markdown、代码块或额外解释。\nJSON Schema: ${schema}`;
+    }
+    extractStructuredAIField(response, field) {
+        const fallback = String(response || '').trim();
+        if (!fallback)
+            return '';
+        try {
+            const parsed = (0, llmJson_1.parseLlmJson)(fallback);
+            if (parsed && typeof parsed === 'object') {
+                if (typeof parsed[field] === 'string' && parsed[field].trim()) {
+                    return parsed[field].trim();
+                }
+                if (field === 'decision' && typeof parsed.reasoning === 'string' && parsed.reasoning.trim()) {
+                    return parsed.reasoning.trim();
+                }
+            }
+        }
+        catch {
+            // Fall back to raw response if structured parse fails.
+        }
+        return fallback;
+    }
+    /**
+     * 判断步骤是否需要展示
+     */
+    shouldDisplay(step) {
+        if (!('display' in step))
+            return false;
+        const display = step.display;
+        if (display === false)
+            return false;
+        if (display === true)
+            return true;
+        if (typeof display === 'object') {
+            return display.show !== false && display.level !== 'none';
+        }
+        return false;
+    }
+    /**
+     * 获取步骤的展示配置
+     */
+    getDisplayConfig(step) {
+        if (!('display' in step))
+            return undefined;
+        const display = step.display;
+        if (typeof display === 'boolean') {
+            return display ? { show: true, level: 'summary' } : undefined;
+        }
+        return display;
+    }
+    /**
+     * 创建展示结果
+     */
+    createDisplayResult(stepId, title, stepResult, displayConfig, sql) {
+        const rawConfig = displayConfig || { level: 'summary', format: 'table' };
+        const { config, issues } = (0, displayContractValidator_1.sanitizeDisplayConfigForRuntime)(rawConfig, {
+            stepId,
+            defaultLevel: 'detail',
+            defaultLayer: 'list',
+            defaultFormat: 'table',
+        });
+        for (const issue of issues) {
+            logger_1.default.warn('SkillExecutor', `Sanitized invalid runtime display config: ${(0, displayContractValidator_1.formatDisplayContractIssue)(issue)}`);
+        }
+        // Skill 引用步骤返回的是嵌套 SkillExecutionResult，展示时需要先解包到真实数据。
+        const data = stepResult.stepType === 'skill'
+            ? this.extractSaveAsValue(stepResult)
+            : stepResult.data;
+        // Extract column definitions from config (runtime data may be ColumnDefinition[] even though type says string[])
+        // This happens because skill YAML is loaded dynamically and contains full column definitions
+        const columnDefinitions = Array.isArray(config.columns)
+            ? config.columns.filter((c) => typeof c === 'object' && c.name)
+            : undefined;
+        // 根据数据类型确定展示格式
+        let displayData;
+        // Special handling for diagnostic step data - preserve the structure
+        // so that transformDeepFrameAnalysis can extract diagnostics
+        if (typeof data === 'object' && data !== null && 'diagnostics' in data && Array.isArray(data.diagnostics)) {
+            // Preserve diagnostic structure for later extraction
+            displayData = data;
+        }
+        else if (Array.isArray(data) && data.length > 0) {
+            // 检查是否是 iterator 结果（包含 itemIndex, item, result）
+            if (this.isIteratorResult(data)) {
+                displayData = this.flattenIteratorResults(data, stepResult.stepType === 'iterator', columnDefinitions);
+            }
+            else {
+                // 普通数组 - 转换为表格格式
+                const firstItem = data[0];
+                if (typeof firstItem === 'object' && firstItem !== null) {
+                    // If display.columns is provided, project data to configured columns only.
+                    // This keeps UI tables concise and avoids leaking internal helper fields.
+                    const configuredColumns = Array.isArray(columnDefinitions)
+                        ? columnDefinitions
+                            .map((d) => d?.name)
+                            .filter((name, idx, arr) => typeof name === 'string' &&
+                            name.length > 0 &&
+                            arr.indexOf(name) === idx)
+                        : [];
+                    const columns = configuredColumns.length > 0 ? configuredColumns : Object.keys(firstItem);
+                    const rows = data.map(row => columns.map(col => this.formatCellValue(row[col])));
+                    displayData = { columns, rows };
+                }
+                else {
+                    // 简单数组
+                    displayData = { columns: ['value'], rows: data.map(v => [this.formatCellValue(v)]) };
+                }
+            }
+        }
+        else if (typeof data === 'string') {
+            displayData = { text: data };
+        }
+        else if (data === null || data === undefined) {
+            displayData = { text: '无数据' };
+        }
+        else if (typeof data === 'object') {
+            // 单个对象 - 转换为键值对表格
+            const columns = ['属性', '值'];
+            const rows = Object.entries(data).map(([key, value]) => [key, this.formatCellValue(value)]);
+            displayData = { columns, rows };
+        }
+        else {
+            displayData = { text: String(data) };
+        }
+        return {
+            stepId,
+            title: config.title || title,
+            level: config.level || 'summary',
+            layer: config.layer, // 分层展示层级
+            format: config.format || 'table',
+            data: displayData,
+            highlight: config.highlight,
+            sql, // 保存原始 SQL
+            expandable: config.expandable, // 是否支持展开查看详细分析
+            metadataFields: config.metadataFields, // 提取到元数据的字段
+            hidden_columns: config.hidden_columns, // 隐藏的列
+            columnDefinitions, // 完整的列定义（包含 hidden 等属性）
+            collapsible: config.collapsible, // 是否可折叠
+            defaultCollapsed: config.defaultCollapsed, // 是否默认折叠
+        };
+    }
+    /**
+     * Build a deterministic "insight summary" DisplayResult from synthesize configs.
+     *
+     * Motivation:
+     * - Skills already carry `synthesize:` configs (role/fields/insights)
+     * - Agents need compact, citeable KPIs + insights without relying on ai_summary
+     *
+     * Current scope (v2):
+     * - Processes config.role in {'overview', 'conclusion', 'list', 'clusters'}
+     * - overview/conclusion: uses first row/object as the KPI row
+     * - list/clusters: summarizes group distributions + top items (best-effort)
+     */
+    buildSynthesizeSummaryDisplayResult(synthesizeData) {
+        if (!Array.isArray(synthesizeData) || synthesizeData.length === 0)
+            return null;
+        const keyRoleItems = synthesizeData.filter(item => item?.success === true &&
+            item?.config &&
+            typeof item.config === 'object' &&
+            ['overview', 'conclusion', 'list', 'clusters'].includes(String(item.config.role)));
+        if (keyRoleItems.length === 0)
+            return null;
+        const metrics = [];
+        const insights = [];
+        const resolvePath = (ctx, path) => {
+            if (!path || !ctx)
+                return undefined;
+            if (!path.includes('.'))
+                return ctx[path];
+            const parts = path.split('.');
+            let cur = ctx;
+            for (const p of parts) {
+                if (cur === null || cur === undefined)
+                    return undefined;
+                cur = cur[p];
+            }
+            return cur;
+        };
+        const applyTemplate = (template, ctx) => {
+            const t = String(template || '');
+            if (!t.includes('{{'))
+                return t;
+            return t.replace(/\{\{\s*([a-zA-Z0-9_\\.]+)\s*\}\}/g, (_m, key) => {
+                const v = resolvePath(ctx, String(key || '').trim());
+                if (v === undefined || v === null)
+                    return '';
+                if (typeof v === 'object') {
+                    try {
+                        return JSON.stringify(v);
+                    }
+                    catch {
+                        return String(v);
+                    }
+                }
+                return String(v);
+            });
+        };
+        const evalConditionOnRow = (condition, rowCtx) => {
+            const expr = String(condition || '').trim();
+            if (!expr)
+                return true;
+            try {
+                // YAML-defined expressions are trusted (skill author controlled).
+                const fn = new Function('ctx', `with (ctx) { return (${expr}); }`);
+                return Boolean(fn(rowCtx));
+            }
+            catch {
+                return false;
+            }
+        };
+        const isPlainObject = (v) => {
+            return typeof v === 'object' && v !== null && !Array.isArray(v);
+        };
+        const toNumber = (v) => {
+            if (typeof v === 'number' && Number.isFinite(v))
+                return v;
+            if (typeof v === 'string') {
+                const s = v.trim();
+                if (!s)
+                    return null;
+                const n = Number(s);
+                return Number.isFinite(n) ? n : null;
+            }
+            return null;
+        };
+        const isIteratorData = (data) => {
+            if (!Array.isArray(data) || data.length === 0)
+                return false;
+            const first = data[0];
+            return isPlainObject(first) && 'itemIndex' in first && 'item' in first && 'result' in first;
+        };
+        const collectTemplateKeys = (template) => {
+            const keys = [];
+            const t = String(template || '');
+            const re = /\{\{\s*([a-zA-Z0-9_\\.]+)\s*\}\}/g;
+            let m;
+            while ((m = re.exec(t)) !== null) {
+                const key = String(m[1] || '').trim();
+                if (!key)
+                    continue;
+                // Only keep root path segment (we don't build nested objects in iterator extraction)
+                const root = key.includes('.') ? key.split('.')[0] : key;
+                if (root)
+                    keys.push(root);
+            }
+            return keys;
+        };
+        const resolveFieldFromSkillResult = (skillResult, field) => {
+            if (!skillResult || !field)
+                return undefined;
+            // 1) Prefer diagnostics for common fields
+            if (field === 'diagnosis' && Array.isArray(skillResult.diagnostics) && skillResult.diagnostics.length > 0) {
+                const d = skillResult.diagnostics[0];
+                if (d && typeof d.diagnosis === 'string' && d.diagnosis.trim())
+                    return d.diagnosis;
+            }
+            if (field === 'confidence' && Array.isArray(skillResult.diagnostics) && skillResult.diagnostics.length > 0) {
+                const d = skillResult.diagnostics[0];
+                if (d && typeof d.confidence === 'number' && Number.isFinite(d.confidence))
+                    return d.confidence;
+            }
+            // 2) Search rawResults step outputs for a field match (first row/object only)
+            const raw = skillResult.rawResults;
+            if (raw && typeof raw === 'object') {
+                for (const stepResult of Object.values(raw)) {
+                    const data = stepResult?.data;
+                    if (Array.isArray(data) && data.length > 0) {
+                        const first = data[0];
+                        if (isPlainObject(first) && field in first)
+                            return first[field];
+                    }
+                    else if (isPlainObject(data) && field in data) {
+                        return data[field];
+                    }
+                }
+            }
+            return undefined;
+        };
+        const resolveClusterBy = (clusterBy) => {
+            if (!clusterBy)
+                return null;
+            if (typeof clusterBy === 'string') {
+                const field = clusterBy.trim();
+                return field ? { field } : null;
+            }
+            if (typeof clusterBy === 'object') {
+                const fieldRaw = clusterBy?.field;
+                const field = typeof fieldRaw === 'string' ? fieldRaw.trim() : '';
+                if (!field)
+                    return null;
+                const labelRaw = clusterBy?.label;
+                const label = typeof labelRaw === 'string' && labelRaw.trim() ? labelRaw.trim() : undefined;
+                return { field, label };
+            }
+            return null;
+        };
+        const extractRowsForListLikeRole = (data, config) => {
+            if (!data)
+                return [];
+            // Determine which fields we may need to synthesize summaries.
+            const needed = new Set();
+            if (config.role === 'clusters') {
+                const c = resolveClusterBy(config.clusterBy);
+                if (c?.field)
+                    needed.add(c.field);
+            }
+            if (Array.isArray(config.groupBy)) {
+                for (const g of config.groupBy) {
+                    if (g?.field)
+                        needed.add(String(g.field));
+                }
+            }
+            if (Array.isArray(config.fields)) {
+                for (const f of config.fields) {
+                    if (f?.key)
+                        needed.add(String(f.key));
+                    if (typeof f?.format === 'string') {
+                        for (const k of collectTemplateKeys(f.format))
+                            needed.add(k);
+                    }
+                }
+            }
+            if (Array.isArray(config.insights)) {
+                for (const i of config.insights) {
+                    if (typeof i?.template === 'string') {
+                        for (const k of collectTemplateKeys(i.template))
+                            needed.add(k);
+                    }
+                }
+            }
+            // Iterator results: [{ itemIndex, item, result }]
+            if (isIteratorData(data)) {
+                const rows = [];
+                for (const it of data) {
+                    const row = isPlainObject(it?.item) ? { ...it.item } : {};
+                    // Fill missing fields from nested SkillExecutionResult
+                    for (const key of needed) {
+                        if (row[key] !== undefined)
+                            continue;
+                        const v = resolveFieldFromSkillResult(it?.result, key);
+                        if (v !== undefined)
+                            row[key] = v;
+                    }
+                    rows.push(row);
+                }
+                return rows;
+            }
+            if (Array.isArray(data)) {
+                return data.filter(isPlainObject);
+            }
+            if (isPlainObject(data))
+                return [data];
+            return [];
+        };
+        const extractRowObject = (data) => {
+            if (!data)
+                return null;
+            // Handle columnar format: { columns: string[], rows: any[][] }
+            // This is the DataEnvelope v2.0 format returned by trace_processor_shell.
+            if (data.columns && Array.isArray(data.columns) &&
+                Array.isArray(data.rows) && data.rows.length > 0) {
+                const row = {};
+                const cols = data.columns;
+                const firstRow = data.rows[0];
+                for (let i = 0; i < cols.length && i < firstRow.length; i++) {
+                    row[cols[i]] = firstRow[i];
+                }
+                return row;
+            }
+            if (Array.isArray(data) && data.length > 0) {
+                const first = data[0];
+                if (first && typeof first === 'object' && !Array.isArray(first)) {
+                    return first;
+                }
+                return null;
+            }
+            if (typeof data === 'object' && !Array.isArray(data)) {
+                return data;
+            }
+            return null;
+        };
+        for (const item of keyRoleItems) {
+            const config = item.config;
+            const role = config?.role;
+            // list/clusters: summarize distribution + top items, best-effort
+            if (role === 'list' || role === 'clusters') {
+                const rows = extractRowsForListLikeRole(item.data, config);
+                if (rows.length === 0)
+                    continue;
+                const stepName = item.stepName || item.stepId;
+                const itemPrefix = keyRoleItems.length > 1 ? `${stepName}: ` : `${stepName}: `;
+                // Group distributions
+                const groupBy = [];
+                if (role === 'clusters') {
+                    const c = resolveClusterBy(config.clusterBy);
+                    if (c?.field) {
+                        groupBy.push({ field: c.field, title: `聚类(${c.label || c.field})` });
+                    }
+                }
+                if (Array.isArray(config.groupBy)) {
+                    for (const g of config.groupBy) {
+                        if (!g || typeof g.field !== 'string' || typeof g.title !== 'string')
+                            continue;
+                        groupBy.push({ field: g.field, title: g.title });
+                    }
+                }
+                const pickDistributionMode = () => {
+                    // If rows contain a numeric percent-like field, aggregate percentages (common for breakdown tables).
+                    const percentKeys = ['percent', 'pct', 'percentage'];
+                    for (const k of percentKeys) {
+                        if (rows.some(r => toNumber(r?.[k]) !== null)) {
+                            return { mode: 'percent', valueKey: k };
+                        }
+                    }
+                    return { mode: 'count' };
+                };
+                const distMode = pickDistributionMode();
+                for (const g of groupBy) {
+                    const field = g.field;
+                    const totalCount = rows.length;
+                    const buckets = new Map();
+                    for (const r of rows) {
+                        const rawKey = r?.[field];
+                        const key = rawKey === undefined || rawKey === null || String(rawKey).trim() === ''
+                            ? 'unknown'
+                            : String(rawKey);
+                        if (!buckets.has(key)) {
+                            buckets.set(key, { count: 0, sum: 0 });
+                        }
+                        const b = buckets.get(key);
+                        b.count += 1;
+                        if (distMode.mode === 'percent' && distMode.valueKey) {
+                            const n = toNumber(r?.[distMode.valueKey]);
+                            if (n !== null)
+                                b.sum = (b.sum || 0) + n;
+                        }
+                    }
+                    const entries = Array.from(buckets.entries()).map(([k, v]) => ({ k, ...v }));
+                    entries.sort((a, b) => {
+                        if (distMode.mode === 'percent')
+                            return (b.sum || 0) - (a.sum || 0);
+                        return b.count - a.count;
+                    });
+                    const top = entries.slice(0, 3);
+                    const segs = [];
+                    for (const e of top) {
+                        if (distMode.mode === 'percent') {
+                            segs.push(`${e.k} ${(e.sum || 0).toFixed(1).replace(/\.0$/, '')}%`);
+                        }
+                        else {
+                            const pct = totalCount > 0 ? Math.round(100 * e.count / totalCount) : 0;
+                            segs.push(`${e.k} ${e.count} (${pct}%)`);
+                        }
+                    }
+                    if (segs.length > 0) {
+                        insights.push(`${g.title}: ${segs.join('，')}`);
+                    }
+                }
+                // Top items: when fields define a (name,value) mapping
+                if (Array.isArray(config.fields) && config.fields.length >= 2) {
+                    const nameField = config.fields[0];
+                    const valueField = config.fields[1];
+                    if (nameField?.key && valueField?.key) {
+                        const items = rows.slice(0, 3).map(r => {
+                            const name = r?.[nameField.key];
+                            const raw = r?.[valueField.key];
+                            const ctx = { ...(r || {}), value: raw };
+                            const formatted = valueField.format ? applyTemplate(valueField.format, ctx).trim() : undefined;
+                            const value = formatted !== undefined && formatted !== null && formatted !== ''
+                                ? formatted
+                                : (raw === undefined || raw === null ? '' : String(raw));
+                            const nameStr = name === undefined || name === null ? '' : String(name);
+                            const s = nameStr ? `${nameStr}: ${value}` : value;
+                            return s.length > 90 ? s.slice(0, 90) + '…' : s;
+                        }).filter(s => typeof s === 'string' && s.trim().length > 0);
+                        if (items.length > 0) {
+                            insights.push(`${itemPrefix}Top: ${items.join('；')}`);
+                        }
+                    }
+                }
+                // Optional row-level insights (evaluate on first row only to keep summary compact)
+                if (Array.isArray(config.insights) && config.insights.length > 0) {
+                    const row0 = rows[0];
+                    if (row0) {
+                        for (const insight of config.insights) {
+                            if (!insight || typeof insight.template !== 'string')
+                                continue;
+                            const ok = insight.condition ? evalConditionOnRow(insight.condition, row0) : true;
+                            if (!ok)
+                                continue;
+                            const rendered = applyTemplate(insight.template, row0).trim();
+                            if (rendered)
+                                insights.push(`${itemPrefix}${rendered}`);
+                        }
+                    }
+                }
+                // Light metric: list size (helps citation and sanity checks)
+                metrics.push({
+                    label: `${stepName} 条目数`,
+                    value: rows.length,
+                });
+                continue;
+            }
+            const row = extractRowObject(item.data);
+            if (!row)
+                continue;
+            // Fields → metrics
+            if (Array.isArray(config.fields)) {
+                for (const field of config.fields) {
+                    if (!field || typeof field.key !== 'string' || typeof field.label !== 'string')
+                        continue;
+                    const raw = row[field.key];
+                    if (raw === undefined || raw === null)
+                        continue;
+                    const ctx = { ...row, value: raw };
+                    const formatted = field.format ? applyTemplate(field.format, ctx) : undefined;
+                    const value = formatted !== undefined && formatted !== null && String(formatted).trim() !== ''
+                        ? String(formatted)
+                        : (typeof raw === 'number' || typeof raw === 'string' ? raw : String(raw));
+                    metrics.push({
+                        label: field.label,
+                        value,
+                    });
+                }
+            }
+            // Insights → short bullet lines
+            if (Array.isArray(config.insights)) {
+                for (const insight of config.insights) {
+                    if (!insight || typeof insight.template !== 'string')
+                        continue;
+                    const ok = insight.condition ? evalConditionOnRow(insight.condition, row) : true;
+                    if (!ok)
+                        continue;
+                    const rendered = applyTemplate(insight.template, row).trim();
+                    if (!rendered)
+                        continue;
+                    const prefix = keyRoleItems.length > 1
+                        ? `${item.stepName || item.stepId}: `
+                        : '';
+                    insights.push(`${prefix}${rendered}`);
+                }
+            }
+        }
+        // Dedupe while preserving order
+        const seenMetric = new Set();
+        const dedupedMetrics = metrics.filter(m => {
+            const k = `${m.label}::${String(m.value)}`;
+            if (seenMetric.has(k))
+                return false;
+            seenMetric.add(k);
+            return true;
+        }).slice(0, 12);
+        const seenInsight = new Set();
+        const dedupedInsights = insights.filter(s => {
+            const k = s.trim();
+            if (!k)
+                return false;
+            if (seenInsight.has(k))
+                return false;
+            seenInsight.add(k);
+            return true;
+        }).slice(0, 8);
+        if (dedupedMetrics.length === 0 && dedupedInsights.length === 0)
+            return null;
+        const content = dedupedInsights.length > 0
+            ? dedupedInsights.map(s => `- ${s}`).join('\n')
+            : '（无显式洞见，见指标）';
+        return {
+            stepId: '__synthesize_summary__',
+            title: '洞见摘要',
+            level: 'key',
+            layer: 'overview',
+            format: 'summary',
+            data: {
+                summary: {
+                    title: '洞见摘要',
+                    content,
+                    metrics: dedupedMetrics,
+                },
+            },
+        };
+    }
+    /**
+     * 创建 DataEnvelope (v2.0 数据契约格式)
+     *
+     * DataEnvelope 是自描述的数据容器，包含:
+     * - meta: 数据来源和版本信息
+     * - data: 实际数据内容
+     * - display: 显示配置（包括列定义）
+     *
+     * 前端可以根据 display.columns 配置进行通用渲染，无需硬编码字段名。
+     */
+    buildDataEnvelope(skillId, stepId, title, stepResult, displayConfig, sql) {
+        // First create the DisplayResult using existing logic
+        const displayResult = this.createDisplayResult(stepId, title, stepResult, displayConfig, sql);
+        // Extract column definitions from config or infer from data
+        const explicitColumns = displayConfig?.columns;
+        // Build the DataEnvelope
+        return (0, dataContract_1.displayResultToEnvelope)(displayResult, skillId, explicitColumns);
+    }
+    /**
+     * 将 SkillExecutionResult 转换为 DataEnvelope 数组
+     *
+     * 用于 v2.0 数据契约，统一 SSE 事件格式
+     */
+    static toDataEnvelopes(result, columnDefinitions) {
+        return result.displayResults.map(dr => {
+            // Prefer external columnDefinitions, fallback to embedded columnDefinitions in DisplayResult
+            const explicitColumns = columnDefinitions?.[dr.stepId] ?? dr.columnDefinitions;
+            // Bridge skillEngine DisplayResult -> dataContract DisplayResult:
+            // dataContract expects metadataConfig.fields, while skillEngine uses metadataFields.
+            const drAny = dr;
+            const drForEnvelope = {
+                ...drAny,
+                metadataConfig: drAny.metadataConfig || (Array.isArray(drAny.metadataFields) ? { fields: drAny.metadataFields } : undefined),
+            };
+            return (0, dataContract_1.displayResultToEnvelope)(drForEnvelope, result.skillId, explicitColumns);
+        });
+    }
+    /**
+     * 检查数据是否是迭代器结果
+     */
+    isIteratorResult(data) {
+        if (data.length === 0)
+            return false;
+        const first = data[0];
+        return typeof first === 'object' && first !== null &&
+            'itemIndex' in first && 'item' in first && 'result' in first;
+    }
+    /**
+     * 将迭代器结果展平为可显示的表格
+     */
+    flattenIteratorResults(data, _isIterator, columnDefinitions) {
+        if (data.length === 0) {
+            return { text: '无迭代结果' };
+        }
+        const resolveFieldFromSkillResult = (skillResult, field) => {
+            if (!skillResult || !field)
+                return undefined;
+            // Prefer diagnostics for common fields
+            if (Array.isArray(skillResult.diagnostics) && skillResult.diagnostics.length > 0) {
+                const d = skillResult.diagnostics[0];
+                if (field === 'diagnosis' && d && typeof d.diagnosis === 'string' && d.diagnosis.trim()) {
+                    return d.diagnosis;
+                }
+                if (field === 'confidence' && d && typeof d.confidence === 'number' && Number.isFinite(d.confidence)) {
+                    return d.confidence;
+                }
+                if (field === 'severity' && d && typeof d.severity === 'string' && d.severity.trim()) {
+                    return d.severity;
+                }
+            }
+            // Search rawResults step outputs for a field match (first row/object only)
+            const raw = skillResult.rawResults;
+            if (raw && typeof raw === 'object') {
+                for (const stepResult of Object.values(raw)) {
+                    const stepData = stepResult?.data;
+                    if (Array.isArray(stepData) && stepData.length > 0) {
+                        const first = stepData[0];
+                        if (first && typeof first === 'object' && !Array.isArray(first) && field in first) {
+                            return first[field];
+                        }
+                    }
+                    else if (stepData && typeof stepData === 'object' && !Array.isArray(stepData) && field in stepData) {
+                        return stepData[field];
+                    }
+                }
+            }
+            return undefined;
+        };
+        const explicitColumns = Array.isArray(columnDefinitions) && columnDefinitions.length > 0
+            ? columnDefinitions.map(c => c.name).filter((n) => typeof n === 'string' && n.trim().length > 0)
+            : [];
+        // If step defines explicit columns, prefer them and attempt to extract values
+        // from both `item` and nested `result` (SkillExecutionResult).
+        if (explicitColumns.length > 0) {
+            const columns = explicitColumns;
+            const rows = data.map((iterItem) => {
+                const item = iterItem.item || {};
+                const skillResult = iterItem.result;
+                return columns.map((col) => {
+                    const v = (item && typeof item === 'object' && col in item)
+                        ? item[col]
+                        : resolveFieldFromSkillResult(skillResult, col);
+                    return this.formatCellValue(v);
+                });
+            });
+            const expandableData = data.map((iterItem) => ({
+                item: iterItem.item,
+                result: {
+                    success: iterItem.result?.success ?? false,
+                    sections: this.convertDisplayResultsToSections(iterItem.result?.displayResults || []),
+                    error: iterItem.result?.error,
+                },
+            }));
+            const summary = this.generateIteratorSummary(data, expandableData);
+            return { columns, rows, expandableData, summary };
+        }
+        // 从 item 中提取关键字段用于显示
+        const firstItem = data[0].item;
+        const itemKeys = Object.keys(firstItem).filter(key => {
+            // 过滤掉太长的字段（如 ts_str 可以保留，但很长的 JSON 字段不要）
+            const value = firstItem[key];
+            if (typeof value === 'string' && value.length > 200)
+                return false;
+            if (typeof value === 'object' && value !== null)
+                return false;
+            return true;
+        }).slice(0, 6); // 最多显示 6 列
+        // 添加一个"状态"列
+        const columns = ['#', ...itemKeys, '分析状态'];
+        const rows = data.map((iterItem, idx) => {
+            const row = [idx + 1];
+            for (const key of itemKeys) {
+                row.push(this.formatCellValue(iterItem.item[key]));
+            }
+            // 添加状态
+            row.push(iterItem.result?.success ? '✓ 完成' : '✗ 失败');
+            return row;
+        });
+        // 提取可展开的详细数据 - 使用 displayResults 而不是 sections
+        const expandableData = data.map((iterItem, idx) => ({
+            item: iterItem.item,
+            result: {
+                success: iterItem.result?.success ?? false,
+                // 将 displayResults 转换为 sections 格式
+                sections: this.convertDisplayResultsToSections(iterItem.result?.displayResults || []),
+                error: iterItem.result?.error,
+            },
+        }));
+        // 生成汇总报告
+        const summary = this.generateIteratorSummary(data, expandableData);
+        return { columns, rows, expandableData, summary };
+    }
+    /**
+     * 生成迭代器结果的汇总报告
+     */
+    generateIteratorSummary(data, expandableData) {
+        if (data.length === 0)
+            return undefined;
+        const successCount = expandableData.filter(d => d.result.success).length;
+        const failCount = data.length - successCount;
+        const firstItem = expandableData[0]?.item || {};
+        const isJankLike = ('frame_id' in firstItem) ||
+            ('jank_type' in firstItem) ||
+            ('vsync_missed' in firstItem);
+        const isStartupLike = ('startup_id' in firstItem) ||
+            ('startup_type' in firstItem) ||
+            ('ttid_ms' in firstItem) ||
+            ('ttfd_ms' in firstItem);
+        // Try to extract key indicators from sections to generate a summary.
+        // Prefer domain-specific summaries; fall back to a generic iterator summary.
+        const summaryLines = [];
+        if (!isJankLike && !isStartupLike) {
+            summaryLines.push(`**迭代分析汇总**`);
+            summaryLines.push('');
+            summaryLines.push(`共分析 ${data.length} 项，成功 ${successCount} 项${failCount > 0 ? `，失败 ${failCount} 项` : ''}。`);
+            return {
+                title: '汇总报告',
+                content: summaryLines.join('\n'),
+            };
+        }
+        if (isStartupLike) {
+            summaryLines.push(`**启动事件分析汇总**`);
+            summaryLines.push('');
+            summaryLines.push(`共分析 ${data.length} 个启动事件，成功 ${successCount} 个${failCount > 0 ? `，失败 ${failCount} 个` : ''}。`);
+            // Startup type distribution (best-effort)
+            const typeCounts = new Map();
+            for (const { item } of expandableData) {
+                const t = item?.startup_type;
+                const k = t === undefined || t === null || String(t).trim() === '' ? 'unknown' : String(t);
+                typeCounts.set(k, (typeCounts.get(k) || 0) + 1);
+            }
+            const typeTop = Array.from(typeCounts.entries()).sort((a, b) => b[1] - a[1]).slice(0, 3);
+            if (typeTop.length > 0) {
+                summaryLines.push('');
+                summaryLines.push(`启动类型分布: ${typeTop.map(([k, v]) => `${k} ${v}`).join('，')}`);
+            }
+            // Top slow startups by dur_ms
+            const withDur = expandableData
+                .map(({ item }) => ({
+                startup_id: item?.startup_id,
+                startup_type: item?.startup_type,
+                dur_ms: Number(item?.dur_ms),
+            }))
+                .filter(r => Number.isFinite(r.dur_ms));
+            withDur.sort((a, b) => b.dur_ms - a.dur_ms);
+            const slowTop = withDur.slice(0, 3);
+            if (slowTop.length > 0) {
+                summaryLines.push('');
+                summaryLines.push('最慢启动:');
+                for (const s of slowTop) {
+                    summaryLines.push(`- startup_id=${s.startup_id ?? '?'} (${s.startup_type ?? 'unknown'}) ${s.dur_ms.toFixed(0)}ms`);
+                }
+            }
+            return {
+                title: '汇总报告',
+                content: summaryLines.join('\n'),
+            };
+        }
+        // Jank/frame iterator summary (existing behavior)
+        summaryLines.push(`**掉帧分析汇总**`);
+        summaryLines.push('');
+        summaryLines.push(`共分析 ${data.length} 个掉帧帧，成功 ${successCount} 个${failCount > 0 ? `，失败 ${failCount} 个` : ''}。`);
+        summaryLines.push('');
+        // 收集所有帧的关键发现
+        const keyFindings = [];
+        for (const { item, result } of expandableData) {
+            if (!result.success || !result.sections)
+                continue;
+            const frameId = item.frame_id || item.id || '?';
+            const jankType = item.jank_type || 'Unknown';
+            const durMs = item.dur_ms || 0;
+            // 从各个 section 中提取关键信息
+            const frameFindings = [];
+            // 主线程耗时操作
+            const mainSlices = result.sections.main_slices || result.sections['主线程耗时操作'];
+            if (mainSlices?.data && mainSlices.data.length > 0) {
+                const topSlice = mainSlices.data[0];
+                frameFindings.push(`主线程 "${topSlice.name}" 耗时 ${topSlice.total_ms}ms`);
+            }
+            // CPU 频率变化时间线
+            const freqTimeline = result.sections.freq_timeline || result.sections['主线程操作CPU频率变化'];
+            if (freqTimeline?.data && freqTimeline.data.length > 0) {
+                const topFreq = freqTimeline.data[0];
+                if (topFreq.freq_timeline && topFreq.state_count > 2) {
+                    frameFindings.push(`${topFreq.slice_name}(${topFreq.total_dur_ms}ms): ${topFreq.freq_timeline}`);
+                }
+            }
+            // 大小核占比
+            const coreAnalysis = result.sections.core_analysis || result.sections['大小核分析'];
+            if (coreAnalysis?.data && coreAnalysis.data.length > 0) {
+                const mainCore = coreAnalysis.data[0];
+                if (mainCore.big_core_pct !== undefined) {
+                    frameFindings.push(`大核占比 ${mainCore.big_core_pct}%`);
+                }
+            }
+            // 四大象限
+            const quadrant = result.sections.quadrant || result.sections['四象限分析'];
+            if (quadrant?.data && quadrant.data.length > 0) {
+                const q = quadrant.data[0];
+                if (q.q3_runnable_ms > 5) {
+                    frameFindings.push(`Runnable 等待 ${q.q3_runnable_ms}ms`);
+                }
+            }
+            // Binder 调用
+            const binder = result.sections.binder_analysis || result.sections['Binder 调用'];
+            if (binder?.data && binder.data.length > 0) {
+                const topBinder = binder.data[0];
+                if (topBinder.total_ms > 5) {
+                    frameFindings.push(`Binder 调用耗时 ${topBinder.total_ms}ms`);
+                }
+            }
+            // 诊断结果
+            const diagnosis = result.sections.frame_diagnosis || result.sections['帧诊断'];
+            if (diagnosis?.diagnostics && diagnosis.diagnostics.length > 0) {
+                const diag = diagnosis.diagnostics[0];
+                if (diag.message) {
+                    frameFindings.push(`诊断: ${diag.message}`);
+                }
+            }
+            if (frameFindings.length > 0) {
+                keyFindings.push(`**帧 #${frameId}** (${jankType}, ${durMs.toFixed(1)}ms): ${frameFindings.join(', ')}`);
+            }
+        }
+        if (keyFindings.length > 0) {
+            summaryLines.push('**关键发现：**');
+            summaryLines.push(...keyFindings.slice(0, 10)); // 最多显示 10 个帧的发现
+            if (keyFindings.length > 10) {
+                summaryLines.push(`... (还有 ${keyFindings.length - 10} 个帧)`);
+            }
+            summaryLines.push('');
+        }
+        summaryLines.push('---');
+        summaryLines.push('*点击每行可展开查看详细分析*');
+        return {
+            title: '掉帧帧详细分析',
+            content: summaryLines.join('\n'),
+        };
+    }
+    /**
+     * 将 displayResults 转换为 sections 格式（用于 iterator 结果）
+     */
+    convertDisplayResultsToSections(displayResults) {
+        const sections = {};
+        for (const dr of displayResults) {
+            // 从 displayResult 的 data 字段中提取实际数据
+            const drData = dr.data;
+            const dataRows = drData?.rows || [];
+            const dataColumns = drData?.columns || [];
+            // 将 rows 转换为对象数组（像 adapter 中的 rowsToObjects）
+            const objects = dataRows.map((row) => {
+                const obj = {};
+                dataColumns.forEach((col, idx) => {
+                    obj[col] = row[idx];
+                });
+                return obj;
+            });
+            sections[dr.stepId] = {
+                title: dr.title,
+                data: objects,
+            };
+        }
+        return sections;
+    }
+    /**
+     * 格式化单元格值用于显示
+     */
+    formatCellValue(value) {
+        if (value === null || value === undefined) {
+            return '-';
+        }
+        if (typeof value === 'number') {
+            return value;
+        }
+        if (typeof value === 'bigint') {
+            return value.toString();
+        }
+        if (typeof value === 'string') {
+            // 截断过长的字符串
+            if (value.length > 100) {
+                return value.substring(0, 97) + '...';
+            }
+            return value;
+        }
+        if (typeof value === 'boolean') {
+            return value ? '是' : '否';
+        }
+        if (typeof value === 'object') {
+            // 对象/数组简化显示
+            const str = JSON.stringify(value);
+            if (str.length > 50) {
+                return str.substring(0, 47) + '...';
+            }
+            return str;
+        }
+        return String(value);
+    }
+    /**
+     * 将行数组转换为对象数组
+     */
+    rowsToObjects(columns, rows) {
+        return rows.map(row => {
+            const obj = {};
+            columns.forEach((col, idx) => {
+                obj[col] = row[idx];
+            });
+            return obj;
+        });
+    }
+}
+exports.SkillExecutor = SkillExecutor;
+/**
+ * Extract findings from skill execution results based on findingsSchema
+ */
+function extractFindings(skillName, findingsSchema, executionContext, stepResults) {
+    if (!findingsSchema || findingsSchema.length === 0) {
+        return [];
+    }
+    const findings = [];
+    for (const schema of findingsSchema) {
+        // Check if this finding type was detected
+        // The condition is implicitly "data exists and has values"
+        // More sophisticated rules can be added later
+        const evidenceData = {};
+        let hasEvidence = false;
+        // Collect evidence from specified fields
+        if (schema.evidenceFields) {
+            for (const fieldPath of schema.evidenceFields) {
+                const value = resolveFieldPath(fieldPath, executionContext, stepResults);
+                if (value !== undefined && value !== null) {
+                    evidenceData[fieldPath] = value;
+                    hasEvidence = true;
+                }
+            }
+        }
+        // Only create finding if we have evidence
+        if (hasEvidence) {
+            // Substitute template placeholders
+            const title = substituteTemplate(schema.titleTemplate, evidenceData);
+            const description = schema.descriptionTemplate
+                ? substituteTemplate(schema.descriptionTemplate, evidenceData)
+                : undefined;
+            findings.push({
+                id: `${skillName}_${schema.id}`,
+                severity: schema.severity,
+                title,
+                description,
+                evidence: evidenceData,
+                sourceModule: skillName,
+                confidence: calculateConfidence(evidenceData, schema.evidenceFields),
+            });
+        }
+    }
+    return findings;
+}
+/**
+ * Extract suggestions from skill execution results based on suggestionsSchema
+ */
+function extractSuggestions(skillName, suggestionsSchema, executionContext, stepResults) {
+    if (!suggestionsSchema || suggestionsSchema.length === 0) {
+        return [];
+    }
+    const suggestions = [];
+    for (const schema of suggestionsSchema) {
+        // Evaluate the condition to see if this suggestion applies
+        const conditionMet = evaluateSuggestionCondition(schema.condition, executionContext, stepResults);
+        if (conditionMet) {
+            // Map parameters from current results to target params
+            const params = {};
+            if (schema.paramsMapping) {
+                for (const [targetKey, sourcePath] of Object.entries(schema.paramsMapping)) {
+                    const value = resolveFieldPath(sourcePath, executionContext, stepResults);
+                    if (value !== undefined) {
+                        params[targetKey] = value;
+                    }
+                }
+            }
+            // Substitute template placeholders in question
+            const questionTemplate = substituteTemplate(schema.questionTemplate, params);
+            suggestions.push({
+                id: `${skillName}_${schema.id}`,
+                targetModule: schema.targetModule,
+                questionTemplate,
+                params,
+                priority: schema.priority ?? 100,
+                reason: `Triggered by condition: ${schema.condition}`,
+            });
+        }
+    }
+    // Sort by priority (lower = higher priority)
+    suggestions.sort((a, b) => a.priority - b.priority);
+    return suggestions;
+}
+/**
+ * Resolve a field path to get its value from context or step results
+ * Supports paths like: "step_id.field_name", "params.value", "variables.name"
+ */
+function resolveFieldPath(path, context, stepResults) {
+    const parts = path.split('.');
+    if (parts.length === 0)
+        return undefined;
+    const root = parts[0];
+    const rest = parts.slice(1);
+    let value;
+    // Try to resolve from different sources
+    if (stepResults[root]?.data !== undefined) {
+        value = stepResults[root].data;
+    }
+    else if (context.variables[root] !== undefined) {
+        value = context.variables[root];
+    }
+    else if (context.params[root] !== undefined) {
+        value = context.params[root];
+    }
+    else if (context.inherited[root] !== undefined) {
+        value = context.inherited[root];
+    }
+    else {
+        return undefined;
+    }
+    // Navigate the rest of the path
+    for (const part of rest) {
+        if (value === undefined || value === null)
+            return undefined;
+        // Handle array index
+        const arrayMatch = part.match(/^(\w+)\[(\d+)\]$/);
+        if (arrayMatch) {
+            value = value[arrayMatch[1]]?.[parseInt(arrayMatch[2])];
+        }
+        else if (Array.isArray(value) && !isNaN(parseInt(part))) {
+            value = value[parseInt(part)];
+        }
+        else {
+            value = value[part];
+        }
+    }
+    return value;
+}
+/**
+ * Substitute template placeholders {field_name} with actual values
+ */
+function substituteTemplate(template, values) {
+    return template.replace(/\{(\w+)\}/g, (_, key) => {
+        const value = values[key];
+        if (value === undefined || value === null)
+            return `{${key}}`;
+        if (typeof value === 'object')
+            return JSON.stringify(value);
+        return String(value);
+    });
+}
+/**
+ * Evaluate a suggestion condition expression
+ * Supports simple comparisons like: "field != value", "field > value"
+ */
+function evaluateSuggestionCondition(condition, context, stepResults) {
+    try {
+        // Parse simple conditions: "field operator value"
+        const operators = ['!=', '==', '>=', '<=', '>', '<', '===', '!=='];
+        for (const op of operators) {
+            const parts = condition.split(op).map(s => s.trim());
+            if (parts.length === 2) {
+                const leftPath = parts[0];
+                const rightValue = parts[1];
+                const leftValue = resolveFieldPath(leftPath, context, stepResults);
+                // Handle quoted string values
+                let right = rightValue;
+                if (rightValue.startsWith('"') && rightValue.endsWith('"')) {
+                    right = rightValue.slice(1, -1);
+                }
+                else if (rightValue.startsWith("'") && rightValue.endsWith("'")) {
+                    right = rightValue.slice(1, -1);
+                }
+                else if (!isNaN(Number(rightValue))) {
+                    right = Number(rightValue);
+                }
+                else if (rightValue === 'true') {
+                    right = true;
+                }
+                else if (rightValue === 'false') {
+                    right = false;
+                }
+                else if (rightValue === 'null' || rightValue === 'undefined') {
+                    right = null;
+                }
+                else {
+                    // It might be a field path
+                    right = resolveFieldPath(rightValue, context, stepResults);
+                }
+                // Perform comparison
+                switch (op) {
+                    case '!=':
+                    case '!==':
+                        return leftValue !== right;
+                    case '==':
+                    case '===':
+                        return leftValue === right;
+                    case '>':
+                        return leftValue > right;
+                    case '<':
+                        return leftValue < right;
+                    case '>=':
+                        return leftValue >= right;
+                    case '<=':
+                        return leftValue <= right;
+                }
+            }
+        }
+        // If no operator found, treat as truthy check
+        const value = resolveFieldPath(condition, context, stepResults);
+        return Boolean(value);
+    }
+    catch (e) {
+        console.warn(`[extractSuggestions] Failed to evaluate condition: ${condition}`, e);
+        return false;
+    }
+}
+/**
+ * Calculate confidence score based on evidence completeness
+ */
+function calculateConfidence(evidence, expectedFields) {
+    if (!expectedFields || expectedFields.length === 0) {
+        return Object.keys(evidence).length > 0 ? 0.7 : 0;
+    }
+    const foundFields = expectedFields.filter(f => evidence[f] !== undefined);
+    return foundFields.length / expectedFields.length;
+}
+// =============================================================================
+// 工厂函数
+// =============================================================================
+function createSkillExecutor(traceProcessor, aiService, eventEmitter) {
+    return new SkillExecutor(traceProcessor, aiService, eventEmitter);
+}
+//# sourceMappingURL=skillExecutor.js.map