@gracker/smartperfetto 1.0.13

package/skills/composite/jank_frame_detail.skill.yaml

@@ -0,0 +1,2065 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (C) 2024-2026 Gracker (Chris)
+# This file is part of SmartPerfetto. See LICENSE for details.
+
+# v2.0: Replaced inline CPU topology CTEs with shared _cpu_topology VIEW
+name: jank_frame_detail
+version: "2.0"
+type: composite
+category: rendering
+tier: S
+
+meta:
+  display_name: "掉帧详情分析"
+  description: "分析特定掉帧的详细原因"
+  icon: "broken_image"
+  tags: [jank, detail, composite]
+
+triggers:
+  keywords:
+    zh: [卡顿帧, 帧详情, 单帧根因, 掉帧原因, jank 详情]
+    en: [jank frame detail, frame root cause, dropped frame detail]
+  patterns:
+    - ".*(卡顿帧|掉帧).*(详情|根因|原因).*"
+    - ".*jank.*frame.*(detail|root cause).*"
+
+prerequisites:
+  modules:
+    - android.binder
+    - android.slices
+    - android.monitor_contention
+    - android.garbage_collection
+    - android.gpu.frequency
+
+inputs:
+  # Primary timing inputs (at least one pair required)
+  - name: start_ts
+    type: timestamp
+    required: false
+    description: "帧开始时间戳(ns)，优先使用"
+  - name: end_ts
+    type: timestamp
+    required: false
+    description: "帧结束时间戳(ns)"
+  # Legacy compatibility (from janky_frame_analysis)
+  - name: frame_ts
+    type: timestamp
+    required: false
+    description: "帧开始时间戳(ns)，兼容旧接口，等同于 start_ts"
+  - name: frame_dur
+    type: duration
+    required: false
+    description: "帧持续时间(ns)，兼容旧接口，用于计算 end_ts"
+  # Thread-specific timing
+  - name: main_start_ts
+    type: timestamp
+    required: false
+  - name: main_end_ts
+    type: timestamp
+    required: false
+  - name: main_dur_ms
+    type: number
+    required: false
+  - name: render_start_ts
+    type: timestamp
+    required: false
+  - name: render_end_ts
+    type: timestamp
+    required: false
+  - name: render_dur_ms
+    type: number
+    required: false
+  # Process/frame identity
+  - name: package
+    type: string
+    required: false
+  - name: pid
+    type: integer
+    required: false
+  - name: frame_id
+    type: integer
+    required: false
+    description: "帧 ID，可选"
+  - name: frame_index
+    type: integer
+    required: false
+  - name: jank_type
+    type: string
+    required: false
+    description: "掉帧类型，可选，默认 'Unknown'"
+  - name: dur_ms
+    type: number
+    required: false
+    description: "帧耗时(ms)，可选，可从 start_ts/end_ts 计算"
+  - name: session_id
+    type: integer
+    required: false
+  - name: layer_name
+    type: string
+    required: false
+  - name: token_gap
+    type: integer
+    required: false
+    description: "display_frame_token 跳跃值 (>1 表示消费端掉帧)"
+  - name: vsync_missed
+    type: integer
+    required: false
+    description: "跳过的 VSync 数量 (token_gap - 1)"
+  - name: jank_responsibility
+    type: string
+    required: false
+    description: "掉帧责任归属: APP / SF / BUFFER_STUFFING / HIDDEN / UNKNOWN"
+  - name: jank_cause
+    type: string
+    required: false
+    description: "掉帧原因说明，由 scrolling_analysis 生成的中文诊断"
+
+identity:
+  policy: required
+  scope: process
+  aliases: [package, process_name]
+  rewriteTo: recommended_process_name_param
+
+steps:
+  - id: init_cpu_topology
+    type: skill
+    name: "初始化 CPU 拓扑"
+    skill: cpu_topology_view
+    display:
+      level: hidden
+    optional: true
+
+  # ===== 数据源检测：Monitor contention 表是否可用（可选）=====
+  - id: monitor_contention_check
+    type: atomic
+    name: "Monitor Contention 数据源检测"
+    display: false
+    sql: |
+      SELECT
+        CASE
+          WHEN EXISTS (
+            SELECT 1 FROM sqlite_master
+            WHERE type = 'table' AND name = 'android_monitor_contention'
+          ) THEN 1
+          ELSE 0
+        END as has_monitor_contention
+    save_as: monitor_contention
+
+  # ===== 数据源检测：GC 表是否可用 =====
+  - id: gc_table_check
+    type: atomic
+    name: "GC 数据源检测"
+    display: false
+    sql: |
+      SELECT
+        CASE
+          WHEN EXISTS (
+            SELECT 1 FROM sqlite_master
+            WHERE type IN ('table', 'view') AND name = 'android_garbage_collection_events'
+          ) THEN 1
+          ELSE 0
+        END as has_gc_table
+    save_as: gc_availability
+    optional: true
+
+  # ===== 数据源检测：GPU 数据是否可用 =====
+  - id: gpu_table_check
+    type: atomic
+    name: "GPU 数据源检测"
+    display: false
+    sql: |
+      SELECT
+        CASE
+          WHEN EXISTS (
+            SELECT 1 FROM slice s
+            JOIN thread_track tt ON s.track_id = tt.id
+            JOIN thread t ON tt.utid = t.utid
+            WHERE (t.name = 'RenderThread' OR t.name GLOB '[0-9]*.raster')
+              AND (s.name GLOB '*Draw*' OR s.name GLOB '*eglSwap*' OR s.name GLOB '*Fence*')
+            LIMIT 1
+          ) THEN 1
+          ELSE 0
+        END as has_gpu_slices,
+        CASE
+          WHEN EXISTS (
+            SELECT 1 FROM sqlite_master
+            WHERE type IN ('table', 'view') AND name = 'android_gpu_frequency'
+          ) THEN 1
+          ELSE 0
+        END as has_gpu_freq
+    save_as: gpu_availability
+    optional: true
+
+  # ===== 数据源检测：Binder 详细数据 =====
+  - id: binder_table_check
+    type: atomic
+    name: "Binder 数据源检测"
+    display: false
+    sql: |
+      SELECT
+        CASE
+          WHEN EXISTS (
+            SELECT 1 FROM sqlite_master
+            WHERE type IN ('table', 'view') AND name = 'android_binder_txns'
+          ) THEN 1
+          ELSE 0
+        END as has_binder_table
+    save_as: binder_availability
+    optional: true
+
+  # 四象限分析：输出格式直接匹配前端展示需求
+  # 前端期望: [{ quadrant, name, dur_ms, percentage }]
+  - id: quadrant_analysis
+    type: atomic
+    name: "四象限分析"
+    optional: true
+    sql_fragments:
+      - fragments/target_threads.sql
+    display:
+      level: key
+      layer: deep
+      title: "四大象限"
+      columns:
+        - name: quadrant
+          label: "象限"
+          type: string
+        - name: name
+          label: "名称"
+          type: string
+        - name: dur_ms
+          label: "耗时"
+          type: duration
+          format: duration_ms
+        - name: percentage
+          label: "占比"
+          type: percentage
+          format: percentage
+    sql: |
+      WITH
+      thread_states AS (
+        SELECT
+          tt.thread_type,
+          ts.state,
+          ts.cpu,
+          ts.dur,
+          CASE
+            WHEN ts.state = 'Running' AND COALESCE(ct.core_type, 'unknown') IN ('prime', 'big') THEN 'Q1_大核运行'
+            WHEN ts.state = 'Running' AND COALESCE(ct.core_type, 'unknown') IN ('medium', 'little') THEN 'Q2_小核运行'
+            WHEN ts.state = 'R' THEN 'Q3_等待调度'
+            WHEN ts.state IN ('D', 'DK') THEN 'Q4a_IO阻塞'
+            WHEN ts.state IN ('S', 'I') THEN 'Q4b_休眠等待'
+            ELSE 'Other'
+          END as quadrant_name
+        FROM thread_state ts
+        JOIN target_threads tt ON ts.utid = tt.utid
+        LEFT JOIN _cpu_topology ct ON ts.cpu = ct.cpu_id
+        WHERE ts.ts >= tt.thread_start_ts
+          AND ts.ts < tt.thread_end_ts
+      ),
+      quadrant_sums AS (
+        SELECT
+          thread_type,
+          quadrant_name,
+          SUM(dur) as dur_ns
+        FROM thread_states
+        WHERE quadrant_name != 'Other'
+        GROUP BY thread_type, quadrant_name
+      ),
+      thread_totals AS (
+        SELECT
+          thread_type,
+          SUM(dur_ns) as total_ns
+        FROM quadrant_sums
+        GROUP BY thread_type
+      )
+      SELECT
+        qs.thread_type || ' ' || qs.quadrant_name as quadrant,
+        qs.thread_type || ' ' || qs.quadrant_name as name,
+        ROUND(qs.dur_ns / 1e6, 2) as dur_ms,
+        ROUND(100.0 * qs.dur_ns / NULLIF(tt.total_ns, 0), 1) as percentage
+      FROM quadrant_sums qs
+      JOIN thread_totals tt ON qs.thread_type = tt.thread_type
+      WHERE qs.dur_ns > 0
+      ORDER BY qs.thread_type, qs.quadrant_name
+    save_as: quadrant_data
+    output_schema:
+      type: array
+      items:
+        quadrant: { type: string, description: "象限标识 (如 MainThread Q1_大核运行)" }
+        name: { type: string, description: "象限名称" }
+        dur_ms: { type: number, description: "持续时间(ms)" }
+        percentage: { type: number, description: "百分比" }
+
+  # Binder 调用：输出格式直接匹配前端展示需求
+  # 前端期望: [{ interface, dur_ms, count }]
+  - id: binder_calls
+    type: atomic
+    name: "Binder 调用"
+    display:
+      level: detail
+      layer: deep
+      title: "Binder 调用"
+      columns:
+        - name: interface
+          label: "服务进程"
+          type: string
+        - name: count
+          label: "调用次数"
+          type: number
+          format: compact
+        - name: dur_ms
+          label: "总耗时"
+          type: duration
+          format: duration_ms
+        - name: max_ms
+          label: "最大耗时"
+          type: duration
+          format: duration_ms
+        - name: sync_count
+          label: "同步调用"
+          type: number
+    sql: |
+      SELECT
+        server_process as interface,
+        COUNT(*) as count,
+        ROUND(SUM(client_dur) / 1e6, 2) as dur_ms,
+        ROUND(MAX(client_dur) / 1e6, 2) as max_ms,
+        SUM(CASE WHEN is_sync = 1 THEN 1 ELSE 0 END) as sync_count
+      FROM android_binder_txns
+      WHERE client_ts >= ${start_ts}
+        AND client_ts < ${end_ts}
+        AND (client_process GLOB '${package}*' OR '${package}' = '')
+      GROUP BY server_process
+      HAVING dur_ms > 0.5
+      ORDER BY dur_ms DESC
+      LIMIT 5
+    save_as: binder_data
+    optional: true
+    output_schema:
+      type: array
+      items:
+        interface: { type: string, description: "服务端进程名" }
+        count: { type: number, description: "调用次数" }
+        dur_ms: { type: number, description: "总耗时(ms)" }
+        max_ms: { type: number, description: "最大单次耗时(ms)" }
+        sync_count: { type: number, description: "同步调用次数" }
+
+  - id: cpu_freq_analysis
+    type: atomic
+    name: "CPU频率"
+    display:
+      level: detail
+      layer: deep
+      title: "CPU 频率"
+      columns:
+        - name: core_type
+          label: "核心类型"
+          type: string
+        - name: avg_freq_mhz
+          label: "平均频率"
+          type: number
+        - name: max_freq_mhz
+          label: "最大频率"
+          type: number
+        - name: min_freq_mhz
+          label: "最小频率"
+          type: number
+    sql: |
+      WITH
+      freq_data AS (
+        SELECT
+          t.cpu,
+          COALESCE(ct.core_type, 'unknown') as core_type,
+          c.value as freq_khz
+        FROM counter c
+        JOIN cpu_counter_track t ON c.track_id = t.id
+        LEFT JOIN _cpu_topology ct ON t.cpu = ct.cpu_id
+        WHERE t.name = 'cpufreq'
+          AND c.ts >= ${start_ts}
+          AND c.ts < ${end_ts}
+      )
+      SELECT
+        core_type,
+        ROUND(AVG(freq_khz) / 1000, 0) as avg_freq_mhz,
+        ROUND(MAX(freq_khz) / 1000, 0) as max_freq_mhz,
+        ROUND(MIN(freq_khz) / 1000, 0) as min_freq_mhz
+      FROM freq_data
+      GROUP BY core_type
+      ORDER BY core_type DESC
+    save_as: freq_data
+    optional: true
+    output_schema:
+      type: array
+      items:
+        core_type: { type: string, description: "核心类型 (big/little)" }
+        avg_freq_mhz: { type: number, description: "平均频率(MHz)" }
+        max_freq_mhz: { type: number, description: "最大频率(MHz)" }
+        min_freq_mhz: { type: number, description: "最小频率(MHz)" }
+
+  # 主线程耗时操作：输出格式直接匹配前端展示需求
+  # 前端期望: [{ name, dur_ms, ts }]
+  - id: main_thread_slices
+    type: atomic
+    name: "主线程耗时操作"
+    display:
+      level: key
+      layer: deep
+      title: "主线程耗时操作"
+      columns:
+        - name: name
+          label: "操作名"
+          type: string
+        - name: dur_ms
+          label: "总耗时"
+          type: duration
+          format: duration_ms
+        - name: count
+          label: "次数"
+          type: number
+          format: compact
+        - name: max_ms
+          label: "最大耗时"
+          type: duration
+          format: duration_ms
+        - name: ts
+          label: "时间戳"
+          type: timestamp
+          clickAction: navigate_timeline
+    sql: |
+      WITH main_thread AS (
+        SELECT t.utid
+        FROM thread t
+        JOIN process p ON t.upid = p.upid
+        WHERE (p.name GLOB '${package}*' OR '${package}' = '')
+          AND (t.tid = p.pid OR t.name GLOB '[0-9]*.ui')
+      )
+      SELECT
+        s.name,
+        ROUND(SUM(s.dur) / 1e6, 2) as dur_ms,
+        COUNT(*) as count,
+        ROUND(MAX(s.dur) / 1e6, 2) as max_ms,
+        printf('%d', MIN(s.ts)) as ts
+      FROM slice s
+      JOIN thread_track tt ON s.track_id = tt.id
+      WHERE tt.utid IN (SELECT utid FROM main_thread)
+        AND s.ts >= COALESCE(${main_start_ts}, ${start_ts})
+        AND s.ts < COALESCE(${main_end_ts}, ${end_ts})
+        AND s.dur >= 1000000
+      GROUP BY s.name
+      HAVING dur_ms > 1
+      ORDER BY dur_ms DESC
+      LIMIT 10
+    save_as: main_slices
+    optional: true
+    output_schema:
+      type: array
+      items:
+        name: { type: string, description: "操作名称" }
+        dur_ms: { type: number, description: "总耗时(ms)" }
+        count: { type: number, description: "执行次数" }
+        max_ms: { type: number, description: "最大单次耗时(ms)" }
+        ts: { type: string, description: "首次时间戳(ns字符串)" }
+
+  # RenderThread 耗时操作：输出格式直接匹配前端展示需求
+  # 前端期望: [{ name, dur_ms, ts }]
+  - id: render_thread_slices
+    type: atomic
+    name: "RenderThread 耗时操作"
+    display:
+      level: key
+      layer: deep
+      title: "RenderThread 耗时操作"
+      columns:
+        - name: name
+          label: "操作名"
+          type: string
+        - name: dur_ms
+          label: "总耗时"
+          type: duration
+          format: duration_ms
+        - name: count
+          label: "次数"
+          type: number
+          format: compact
+        - name: max_ms
+          label: "最大耗时"
+          type: duration
+          format: duration_ms
+        - name: avg_ms
+          label: "平均耗时"
+          type: duration
+          format: duration_ms
+        - name: ts
+          label: "时间戳"
+          type: timestamp
+          clickAction: navigate_timeline
+    sql: |
+      WITH render_thread AS (
+        SELECT t.utid
+        FROM thread t
+        JOIN process p ON t.upid = p.upid
+        WHERE (p.name GLOB '${package}*' OR '${package}' = '')
+          AND (t.name = 'RenderThread' OR t.name GLOB '[0-9]*.raster')
+      )
+      SELECT
+        s.name,
+        ROUND(SUM(s.dur) / 1e6, 2) as dur_ms,
+        COUNT(*) as count,
+        ROUND(MAX(s.dur) / 1e6, 2) as max_ms,
+        ROUND(AVG(s.dur) / 1e6, 2) as avg_ms,
+        printf('%d', MIN(s.ts)) as ts
+      FROM slice s
+      JOIN thread_track tt ON s.track_id = tt.id
+      WHERE tt.utid IN (SELECT utid FROM render_thread)
+        AND s.ts >= COALESCE(${render_start_ts}, ${start_ts})
+        AND s.ts < COALESCE(${render_end_ts}, ${end_ts})
+        AND s.dur >= 500000
+      GROUP BY s.name
+      HAVING dur_ms > 0.5
+      ORDER BY dur_ms DESC
+      LIMIT 10
+    save_as: render_slices
+    optional: true
+    output_schema:
+      type: array
+      items:
+        name: { type: string, description: "操作名称" }
+        dur_ms: { type: number, description: "总耗时(ms)" }
+        count: { type: number, description: "执行次数" }
+        max_ms: { type: number, description: "最大单次耗时(ms)" }
+        avg_ms: { type: number, description: "平均耗时(ms)" }
+        ts: { type: string, description: "首次时间戳(ns字符串)" }
+
+  - id: cpu_freq_timeline
+    type: atomic
+    name: "CPU 频率变化时间线"
+    display:
+      level: detail
+      layer: deep
+      title: "CPU 频率变化"
+      columns:
+        - name: ts
+          label: "时间戳"
+          type: timestamp
+          clickAction: navigate_timeline
+        - name: relative_ms
+          label: "相对时间"
+          type: duration
+          format: duration_ms
+        - name: cpu
+          label: "CPU"
+          type: number
+        - name: core_type
+          label: "核心类型"
+          type: string
+        - name: freq_mhz
+          label: "频率"
+          type: number
+        - name: change_direction
+          label: "变化"
+          type: enum
+    sql: |
+      WITH
+      freq_events AS (
+        SELECT
+          c.ts,
+          t.cpu,
+          c.value as freq_khz,
+          COALESCE(ct.core_type, 'unknown') as core_type,
+          LAG(c.value) OVER (PARTITION BY t.cpu ORDER BY c.ts) as prev_freq_khz
+        FROM counter c
+        JOIN cpu_counter_track t ON c.track_id = t.id
+        LEFT JOIN _cpu_topology ct ON t.cpu = ct.cpu_id
+        WHERE t.name = 'cpufreq'
+          AND c.ts >= ${start_ts}
+          AND c.ts < ${end_ts}
+      )
+      SELECT
+        printf('%d', ts) as ts,
+        ROUND((ts - ${start_ts}) / 1e6, 2) as relative_ms,
+        cpu,
+        core_type,
+        ROUND(freq_khz / 1000, 0) as freq_mhz,
+        ROUND(COALESCE(prev_freq_khz, freq_khz) / 1000, 0) as prev_freq_mhz,
+        CASE 
+          WHEN freq_khz > COALESCE(prev_freq_khz, freq_khz) THEN 'up'
+          WHEN freq_khz < COALESCE(prev_freq_khz, freq_khz) THEN 'down'
+          ELSE 'stable'
+        END as change_direction
+      FROM freq_events
+      WHERE freq_khz != COALESCE(prev_freq_khz, 0)
+      ORDER BY ts, cpu
+      LIMIT 50
+    save_as: freq_timeline
+    optional: true
+
+  - id: lock_contention
+    type: atomic
+    name: "锁竞争分析"
+    display:
+      level: detail
+      layer: deep
+      title: "锁竞争"
+      columns:
+        - name: blocking_method
+          label: "持锁方法"
+          type: string
+          format: code
+        - name: blocking_thread_name
+          label: "持锁线程"
+          type: string
+        - name: blocked_method
+          label: "等锁方法"
+          type: string
+          format: code
+        - name: blocked_thread_name
+          label: "等锁线程"
+          type: string
+        - name: main_blocked
+          label: "主线程被阻"
+          type: boolean
+        - name: wait_ms
+          label: "等待时间"
+          type: duration
+          format: duration_ms
+        - name: waiter_count
+          label: "等待数"
+          type: number
+    sql: |
+      SELECT
+        short_blocking_method as blocking_method,
+        blocking_thread_name,
+        short_blocked_method as blocked_method,
+        blocked_thread_name,
+        CASE WHEN is_blocked_thread_main THEN 1 ELSE 0 END as main_blocked,
+        ROUND(dur / 1e6, 2) as wait_ms,
+        waiter_count
+      FROM android_monitor_contention
+      WHERE ts >= ${start_ts}
+        AND ts < ${end_ts}
+        AND (process_name GLOB '${package}*' OR '${package}' = '')
+        AND dur >= 500000
+      ORDER BY dur DESC
+      LIMIT 5
+    save_as: lock_data
+    optional: true
+    condition: "monitor_contention.data[0]?.has_monitor_contention === 1"
+
+  # ===== GC 与帧重叠分析 =====
+  - id: gc_in_frame
+    type: atomic
+    name: "GC 影响分析"
+    display:
+      level: detail
+      layer: deep
+      title: "GC 与帧重叠"
+      columns:
+        - name: gc_type
+          label: "GC 类型"
+          type: string
+        - name: gc_count
+          label: "GC 次数"
+          type: number
+        - name: total_dur_ms
+          label: "总耗时"
+          type: duration
+          format: duration_ms
+        - name: overlap_ms
+          label: "与帧重叠"
+          type: duration
+          format: duration_ms
+        - name: max_dur_ms
+          label: "最大单次"
+          type: duration
+          format: duration_ms
+    sql: |
+      WITH gc_events AS (
+        SELECT
+          gc.tid,
+          gc.gc_type,
+          gc.gc_ts as gc_ts,
+          gc.gc_dur as gc_dur,
+          -- Calculate overlap with frame window
+          MAX(gc.gc_ts, ${start_ts}) as overlap_start,
+          MIN(gc.gc_ts + gc.gc_dur, ${end_ts}) as overlap_end
+        FROM android_garbage_collection_events gc
+        JOIN thread t ON gc.tid = t.tid
+        JOIN process p ON t.upid = p.upid
+        WHERE (p.name GLOB '${package}*' OR '${package}' = '')
+          AND gc.gc_ts < ${end_ts}
+          AND gc.gc_ts + gc.gc_dur > ${start_ts}
+      )
+      SELECT
+        gc_type,
+        COUNT(*) as gc_count,
+        ROUND(SUM(gc_dur) / 1e6, 2) as total_dur_ms,
+        ROUND(SUM(CASE WHEN overlap_end > overlap_start THEN overlap_end - overlap_start ELSE 0 END) / 1e6, 2) as overlap_ms,
+        ROUND(MAX(gc_dur) / 1e6, 2) as max_dur_ms
+      FROM gc_events
+      GROUP BY gc_type
+      HAVING overlap_ms > 0
+      ORDER BY overlap_ms DESC
+    save_as: gc_data
+    optional: true
+    condition: "gc_availability?.data?.[0]?.has_gc_table === 1"
+
+  # ===== IO 阻塞分析（D/DK 状态）=====
+  - id: io_blocking
+    type: atomic
+    name: "IO 阻塞分析"
+    display:
+      level: detail
+      layer: deep
+      title: "IO 阻塞"
+      columns:
+        - name: thread_name
+          label: "线程"
+          type: string
+        - name: blocked_count
+          label: "阻塞次数"
+          type: number
+        - name: total_ms
+          label: "总阻塞时间"
+          type: duration
+          format: duration_ms
+        - name: max_ms
+          label: "最大单次"
+          type: duration
+          format: duration_ms
+        - name: io_cause
+          label: "等待原因"
+          type: string
+    sql: |
+      WITH target_threads AS (
+        SELECT t.utid, t.tid, t.name as thread_name, p.pid
+        FROM thread t
+        JOIN process p ON t.upid = p.upid
+        WHERE (p.name GLOB '${package}*' OR '${package}' = '')
+          AND (t.tid = p.pid OR t.name = 'RenderThread' OR t.name GLOB '[0-9]*.raster' OR t.name GLOB '[0-9]*.ui')
+      ),
+      io_states AS (
+        SELECT
+          tt.thread_name,
+          ts.dur,
+          ts.state,
+          ts.io_wait,
+          ts.blocked_function
+        FROM thread_state ts
+        JOIN target_threads tt ON ts.utid = tt.utid
+        WHERE ts.ts >= ${start_ts}
+          AND ts.ts < ${end_ts}
+          AND ts.state IN ('D', 'DK')
+          AND ts.dur > 100000
+      )
+      SELECT
+        thread_name,
+        COUNT(*) as blocked_count,
+        ROUND(SUM(dur) / 1e6, 2) as total_ms,
+        ROUND(MAX(dur) / 1e6, 2) as max_ms,
+        COALESCE(
+          MAX(blocked_function),
+          CASE WHEN MAX(io_wait) = 1 THEN 'IO wait' ELSE 'kernel wait' END
+        ) as io_cause
+      FROM io_states
+      GROUP BY thread_name
+      HAVING total_ms > 0.1
+      ORDER BY total_ms DESC
+    save_as: io_data
+    optional: true
+
+  # ===== P0: 调度延迟分析 (引用 atomic skill) =====
+  - id: sched_latency
+    skill: sched_latency_in_range
+    params:
+      start_ts: "${start_ts}"
+      end_ts: "${end_ts}"
+      package: "${package}"
+    save_as: sched_data
+    optional: true
+
+  # ===== P0: 大小核迁移分析 (引用 atomic skill) =====
+  - id: task_migration
+    skill: task_migration_in_range
+    params:
+      start_ts: "${start_ts}"
+      end_ts: "${end_ts}"
+      package: "${package}"
+    save_as: migration_data
+    optional: true
+
+  # ===== P0: GPU 渲染操作分析 (引用 atomic skill) =====
+  - id: gpu_render
+    skill: gpu_render_in_range
+    params:
+      start_ts: "${start_ts}"
+      end_ts: "${end_ts}"
+      package: "${package}"
+    save_as: gpu_data
+    optional: true
+    condition: "gpu_availability?.data?.[0]?.has_gpu_slices === 1"
+
+  # ===== P0: Binder 阻塞分析 (引用 atomic skill) =====
+  - id: binder_blocking
+    skill: binder_blocking_in_range
+    params:
+      start_ts: "${start_ts}"
+      end_ts: "${end_ts}"
+      package: "${package}"
+    save_as: binder_blocking_data
+    optional: true
+    condition: "binder_availability?.data?.[0]?.has_binder_table === 1"
+
+  # ===== P0: CPU 限频检测 (引用 atomic skill) =====
+  - id: cpu_throttling
+    skill: cpu_throttling_in_range
+    params:
+      start_ts: "${start_ts}"
+      end_ts: "${end_ts}"
+    save_as: throttling_data
+    optional: true
+
+  # ===== P0: CPU 簇负载分析 (引用 atomic skill) =====
+  - id: cpu_cluster_load
+    skill: cpu_cluster_load_in_range
+    params:
+      start_ts: "${start_ts}"
+      end_ts: "${end_ts}"
+    save_as: cluster_load_data
+    optional: true
+
+  # ===== P0: 内存页面错误分析 (引用 atomic skill) =====
+  - id: page_fault
+    skill: page_fault_in_range
+    params:
+      start_ts: "${start_ts}"
+      end_ts: "${end_ts}"
+      package: "${package}"
+    save_as: page_fault_data
+    optional: true
+
+  # ===== P1: SurfaceFlinger 合成分析 (引用 atomic skill) =====
+  - id: sf_composition
+    skill: sf_composition_in_range
+    params:
+      start_ts: "${start_ts}"
+      end_ts: "${end_ts}"
+    save_as: sf_data
+    optional: true
+
+  # ===== P1: GPU 频率分析 (引用 atomic skill) =====
+  - id: gpu_freq
+    skill: gpu_freq_in_range
+    params:
+      start_ts: "${start_ts}"
+      end_ts: "${end_ts}"
+    save_as: gpu_freq_data
+    optional: true
+    condition: "gpu_availability?.data?.[0]?.has_gpu_freq === 1"
+
+  # ===== P1: VSync 对齐分析 (引用 atomic skill) =====
+  - id: vsync_alignment
+    skill: vsync_alignment_in_range
+    params:
+      start_ts: "${start_ts}"
+      end_ts: "${end_ts}"
+    save_as: vsync_data
+    optional: true
+
+  # ===== P1: 渲染流水线分解 (引用 atomic skill) =====
+  - id: render_pipeline
+    skill: render_pipeline_latency
+    params:
+      start_ts: "${start_ts}"
+      end_ts: "${end_ts}"
+      main_start_ts: "${main_start_ts}"
+      main_end_ts: "${main_end_ts}"
+      render_start_ts: "${render_start_ts}"
+      render_end_ts: "${render_end_ts}"
+    save_as: pipeline_data
+    optional: true
+
+  # ===== 根因分析总结：综合所有数据给出明确结论 =====
+  - id: root_cause_summary
+    type: atomic
+    name: "根因分析"
+    sql_fragments:
+      - fragments/vsync_config.sql
+      - fragments/target_threads.sql
+      - fragments/thread_states_quadrant.sql
+    display:
+      level: key
+      layer: deep
+      title: "🎯 根因分析"
+      columns:
+        - name: primary_cause
+          label: "主要原因"
+          type: string
+        - name: deep_reason
+          label: "为什么慢"
+          type: string
+        - name: optimization_hint
+          label: "优化方向"
+          type: string
+        - name: reason_code
+          label: "原因类型"
+          type: enum
+        - name: secondary_info
+          label: "附加信息"
+          type: string
+        - name: confidence
+          label: "置信度"
+          type: string
+        - name: cause_type
+          label: "原因类型"
+          type: enum
+        - name: mechanism_group
+          label: "机制分组"
+          type: enum
+        - name: supply_constraint
+          label: "资源问题"
+          type: enum
+        - name: trigger_layer
+          label: "触发层"
+          type: enum
+        - name: amplification_path
+          label: "放大因素"
+          type: enum
+        - name: frame_dur_ms
+          label: "帧耗时"
+          type: duration
+          format: duration_ms
+        - name: jank_type
+          label: "掉帧类型"
+          type: string
+    sql: |
+      -- 根因分析: 综合四象限、CPU频率、耗时操作等数据，输出明确的根因结论
+      -- CTEs vsync_ticks, vsync_config, target_threads, thread_states injected via sql_fragments
+      WITH
+      -- 3. 计算各线程四象限百分比
+      quadrant_pct AS (
+        SELECT
+          thread_type,
+          quadrant,
+          dur_ns,
+          ROUND(100.0 * dur_ns / NULLIF(SUM(dur_ns) OVER (PARTITION BY thread_type), 0), 1) as pct
+        FROM thread_states
+        WHERE quadrant != 'Other'
+      ),
+      main_summary AS (
+        SELECT
+          COALESCE(SUM(CASE WHEN quadrant = 'Q1' THEN pct ELSE 0 END), 0) as q1,
+          COALESCE(SUM(CASE WHEN quadrant = 'Q2' THEN pct ELSE 0 END), 0) as q2,
+          COALESCE(SUM(CASE WHEN quadrant = 'Q3' THEN pct ELSE 0 END), 0) as q3,
+          COALESCE(SUM(CASE WHEN quadrant = 'Q4a' THEN pct ELSE 0 END), 0) as q4a,
+          COALESCE(SUM(CASE WHEN quadrant = 'Q4b' THEN pct ELSE 0 END), 0) as q4b
+        FROM quadrant_pct WHERE thread_type = 'MainThread'
+      ),
+      render_summary AS (
+        SELECT
+          COALESCE(SUM(CASE WHEN quadrant = 'Q1' THEN pct ELSE 0 END), 0) as q1,
+          COALESCE(SUM(CASE WHEN quadrant = 'Q2' THEN pct ELSE 0 END), 0) as q2,
+          COALESCE(SUM(CASE WHEN quadrant = 'Q3' THEN pct ELSE 0 END), 0) as q3,
+          COALESCE(SUM(CASE WHEN quadrant = 'Q4a' THEN pct ELSE 0 END), 0) as q4a,
+          COALESCE(SUM(CASE WHEN quadrant = 'Q4b' THEN pct ELSE 0 END), 0) as q4b
+        FROM quadrant_pct WHERE thread_type = 'RenderThread'
+      ),
+      -- 4. 获取最耗时的主线程操作
+      main_thread_utid AS (
+        SELECT t.utid
+        FROM thread t JOIN process p ON t.upid = p.upid
+        WHERE (p.name GLOB '${package}*' OR '${package}' = '') AND (t.tid = p.pid OR t.name GLOB '[0-9]*.ui')
+      ),
+      main_thread_tid AS (
+        SELECT t.tid
+        FROM thread t JOIN process p ON t.upid = p.upid
+        WHERE (p.name GLOB '${package}*' OR '${package}' = '') AND (t.tid = p.pid OR t.name GLOB '[0-9]*.ui')
+      ),
+      top_slice AS (
+        SELECT
+          s.name,
+          s.ts as slice_ts,
+          s.dur as slice_dur_ns,
+          ROUND(s.dur / 1e6, 2) as dur_ms
+        FROM slice s
+        JOIN thread_track tt ON s.track_id = tt.id
+        WHERE tt.utid IN (SELECT utid FROM main_thread_utid)
+          AND s.ts >= COALESCE(${main_start_ts}, ${start_ts})
+          AND s.ts < COALESCE(${main_end_ts}, ${end_ts})
+          AND s.dur >= 1000000
+        ORDER BY s.dur DESC
+        LIMIT 1
+      ),
+      top_slice_bounds AS (
+        SELECT
+          slice_ts as slice_start_ns,
+          slice_ts + slice_dur_ns as slice_end_ns,
+          slice_dur_ns
+        FROM top_slice
+      ),
+      top_slice_state_overlap AS (
+        SELECT
+          ts.state,
+          ts.cpu,
+          COALESCE(ct.core_type, 'unknown') as core_type,
+          (
+            CASE
+              WHEN ts.ts + ts.dur < b.slice_end_ns THEN ts.ts + ts.dur
+              ELSE b.slice_end_ns
+            END
+            -
+            CASE
+              WHEN ts.ts > b.slice_start_ns THEN ts.ts
+              ELSE b.slice_start_ns
+            END
+          ) as overlap_ns
+        FROM thread_state ts
+        JOIN main_thread_utid mtu ON ts.utid = mtu.utid
+        JOIN top_slice_bounds b
+        LEFT JOIN _cpu_topology ct ON ts.cpu = ct.cpu_id
+        WHERE ts.ts < b.slice_end_ns
+          AND ts.ts + ts.dur > b.slice_start_ns
+      ),
+      top_slice_cpu_mix AS (
+        SELECT
+          ROUND(
+            100.0 * SUM(CASE WHEN state = 'Running' AND core_type IN ('medium', 'little') AND overlap_ns > 0 THEN overlap_ns ELSE 0 END)
+            / NULLIF((SELECT slice_dur_ns FROM top_slice_bounds), 0),
+            1
+          ) as little_run_pct,
+          ROUND(
+            100.0 * SUM(CASE WHEN state = 'Running' AND core_type IN ('prime', 'big') AND overlap_ns > 0 THEN overlap_ns ELSE 0 END)
+            / NULLIF((SELECT slice_dur_ns FROM top_slice_bounds), 0),
+            1
+          ) as big_run_pct,
+          ROUND(
+            100.0 * SUM(CASE WHEN state = 'R' AND overlap_ns > 0 THEN overlap_ns ELSE 0 END)
+            / NULLIF((SELECT slice_dur_ns FROM top_slice_bounds), 0),
+            1
+          ) as runnable_pct,
+          ROUND(
+            100.0 * SUM(CASE WHEN state IN ('S', 'D', 'I', 'DK') AND overlap_ns > 0 THEN overlap_ns ELSE 0 END)
+            / NULLIF((SELECT slice_dur_ns FROM top_slice_bounds), 0),
+            1
+          ) as blocked_pct
+        FROM top_slice_state_overlap
+      ),
+      -- 5. 获取 CPU 频率
+      freq_info AS (
+        SELECT
+          ROUND(AVG(CASE WHEN ct.core_type IN ('prime', 'big') THEN c.value END) / 1000, 0) as big_avg_freq,
+          ROUND(MAX(CASE WHEN ct.core_type IN ('prime', 'big') THEN c.value END) / 1000, 0) as big_max_freq,
+          ROUND(MIN(CASE WHEN ct.core_type IN ('prime', 'big') THEN c.value END) / 1000, 0) as big_min_freq,
+          ROUND(AVG(CASE WHEN ct.core_type IN ('medium', 'little') THEN c.value END) / 1000, 0) as little_avg_freq,
+          ROUND(MAX(CASE WHEN ct.core_type IN ('medium', 'little') THEN c.value END) / 1000, 0) as little_max_freq,
+          ROUND(MIN(CASE WHEN ct.core_type IN ('medium', 'little') THEN c.value END) / 1000, 0) as little_min_freq
+        FROM counter c
+        JOIN cpu_counter_track t ON c.track_id = t.id
+        LEFT JOIN _cpu_topology ct ON t.cpu = ct.cpu_id
+        WHERE t.name = 'cpufreq'
+          AND c.ts >= ${start_ts} AND c.ts < ${end_ts}
+      ),
+      top_slice_freq AS (
+        SELECT
+          ROUND(AVG(CASE WHEN ct.core_type IN ('prime', 'big') THEN c.value END) / 1000, 0) as top_big_avg_freq_mhz,
+          ROUND(MAX(CASE WHEN ct.core_type IN ('prime', 'big') THEN c.value END) / 1000, 0) as top_big_max_freq_mhz,
+          ROUND(MIN(CASE WHEN ct.core_type IN ('prime', 'big') THEN c.value END) / 1000, 0) as top_big_min_freq_mhz,
+          ROUND(AVG(CASE WHEN ct.core_type IN ('medium', 'little') THEN c.value END) / 1000, 0) as top_little_avg_freq_mhz
+        FROM counter c
+        JOIN cpu_counter_track t ON c.track_id = t.id
+        LEFT JOIN _cpu_topology ct ON t.cpu = ct.cpu_id
+        WHERE t.name = 'cpufreq'
+          AND EXISTS (SELECT 1 FROM top_slice_bounds)
+          AND c.ts >= (SELECT slice_start_ns FROM top_slice_bounds)
+          AND c.ts < (SELECT slice_end_ns FROM top_slice_bounds)
+      ),
+      big_freq_window AS (
+        SELECT c.ts, c.value as freq_khz
+        FROM counter c
+        JOIN cpu_counter_track t ON c.track_id = t.id
+        WHERE t.name = 'cpufreq'
+          AND t.cpu IN (SELECT cpu_id FROM _cpu_topology WHERE core_type IN ('prime', 'big'))
+          AND c.ts >= ${start_ts}
+          AND c.ts < ${end_ts}
+      ),
+      big_freq_stats AS (
+        SELECT
+          MAX(freq_khz) as peak_khz,
+          MIN(freq_khz) as min_khz,
+          AVG(freq_khz) as avg_khz
+        FROM big_freq_window
+      ),
+      big_freq_ramp AS (
+        SELECT
+          ROUND(
+            (
+              COALESCE(
+                MIN(
+                  CASE
+                    WHEN b.freq_khz >=
+                      CASE
+                        WHEN s.peak_khz IS NULL THEN NULL
+                        WHEN s.peak_khz * 0.70 > 1800000 THEN s.peak_khz * 0.70
+                        ELSE 1800000
+                      END
+                    THEN b.ts
+                  END
+                ),
+                ${end_ts}
+              ) - ${start_ts}
+            ) / 1e6,
+            2
+          ) as ramp_to_high_ms,
+          ROUND(
+            (COALESCE(MIN(CASE WHEN b.freq_khz >= 2000000 THEN b.ts END), ${end_ts}) - ${start_ts}) / 1e6,
+            2
+          ) as ramp_to_2g_ms
+        FROM big_freq_window b
+        CROSS JOIN big_freq_stats s
+      ),
+      -- 6. IO 阻塞检测（主线程 D/DK 状态）
+      io_block AS (
+        SELECT COALESCE(ROUND(SUM(ts2.dur) / 1e6, 2), 0) as io_block_ms
+        FROM thread_state ts2
+        JOIN target_threads tt2 ON ts2.utid = tt2.utid
+        WHERE tt2.thread_type = 'MainThread'
+          AND ts2.ts >= ${start_ts} AND ts2.ts < ${end_ts}
+          AND ts2.state IN ('D', 'DK')
+      ),
+      -- 7. 调度延迟检测（Runnable 等待）
+      sched_latency AS (
+        SELECT
+          COALESCE(ROUND(MAX(ts3.dur) / 1e6, 2), 0) as max_sched_ms,
+          COALESCE(ROUND(SUM(ts3.dur) / 1e6, 2), 0) as total_sched_ms
+        FROM thread_state ts3
+        JOIN target_threads tt3 ON ts3.utid = tt3.utid
+        WHERE tt3.thread_type = 'MainThread'
+          AND ts3.ts >= ${start_ts} AND ts3.ts < ${end_ts}
+          AND ts3.state = 'R'
+      ),
+      -- 8. GPU Fence / GPU 同步检测
+      -- 包含 GPU fence 等待、eglSwapBuffers（GPU backpressure）、dequeueBuffer（BufferQueue 阻塞）
+      gpu_fence AS (
+        SELECT COALESCE(ROUND(SUM(s.dur) / 1e6, 2), 0) as fence_ms
+        FROM slice s
+        JOIN thread_track tt ON s.track_id = tt.id
+        JOIN thread t ON tt.utid = t.utid
+        JOIN process p ON t.upid = p.upid
+        WHERE (p.name GLOB '${package}*' OR '${package}' = '')
+          AND (t.name = 'RenderThread' OR t.name GLOB '[0-9]*.raster')
+          AND s.ts >= ${start_ts} AND s.ts < ${end_ts}
+          AND (s.name GLOB '*Fence*' OR s.name GLOB '*fence*'
+               OR s.name GLOB '*eglSwapBuffers*'
+               OR s.name GLOB '*dequeueBuffer*')
+      ),
+      -- 8b. Shader 编译检测（RenderThread 上的着色器编译/管线创建 slice）
+      shader_compile AS (
+        SELECT
+          COALESCE(ROUND(SUM(s.dur) / 1e6, 2), 0) as shader_ms,
+          COUNT(*) as shader_count
+        FROM slice s
+        JOIN thread_track tt ON s.track_id = tt.id
+        JOIN thread t ON tt.utid = t.utid
+        JOIN process p ON t.upid = p.upid
+        WHERE (p.name GLOB '${package}*' OR '${package}' = '')
+          AND (t.name = 'RenderThread' OR t.name GLOB '[0-9]*.raster')
+          AND s.ts >= ${start_ts} AND s.ts < ${end_ts}
+          AND (s.name GLOB '*shader*' OR s.name GLOB '*Shader*'
+               OR s.name GLOB '*Compile*' OR s.name GLOB '*compile*'
+               OR s.name GLOB 'GrGLGpu*'
+               OR s.name GLOB '*Pipeline*Create*'
+               OR s.name GLOB '*programCache*')
+      ),
+      -- 9. CPU 簇负载检测（动态核心计数，适配所有 SoC 拓扑）
+      cluster_core_counts AS (
+        SELECT
+          COUNT(DISTINCT CASE WHEN COALESCE(ct.core_type, 'unknown') IN ('prime', 'big') THEN ts.cpu END) as big_cores,
+          COUNT(DISTINCT CASE WHEN COALESCE(ct.core_type, 'unknown') IN ('medium', 'little') THEN ts.cpu END) as little_cores
+        FROM thread_state ts
+        LEFT JOIN _cpu_topology ct ON ts.cpu = ct.cpu_id
+        WHERE ts.ts < ${end_ts}
+          AND ts.ts + ts.dur > ${start_ts}
+          AND ts.state = 'Running'
+          AND ts.cpu IS NOT NULL
+      ),
+      cluster_load AS (
+        SELECT
+          ROUND(100.0 * SUM(CASE WHEN COALESCE(ct.core_type, 'unknown') IN ('prime', 'big') THEN
+            MIN(ts.ts + ts.dur, ${end_ts}) - MAX(ts.ts, ${start_ts})
+          ELSE 0 END) / NULLIF((${end_ts} - ${start_ts}) * MAX((SELECT big_cores FROM cluster_core_counts), 1), 0), 1) as big_load_pct,
+          ROUND(100.0 * SUM(CASE WHEN COALESCE(ct.core_type, 'unknown') IN ('medium', 'little') THEN
+            MIN(ts.ts + ts.dur, ${end_ts}) - MAX(ts.ts, ${start_ts})
+          ELSE 0 END) / NULLIF((${end_ts} - ${start_ts}) * MAX((SELECT little_cores FROM cluster_core_counts), 1), 0), 1) as little_load_pct
+        FROM thread_state ts
+        LEFT JOIN _cpu_topology ct ON ts.cpu = ct.cpu_id
+        WHERE ts.ts < ${end_ts}
+          AND ts.ts + ts.dur > ${start_ts}
+          AND ts.state = 'Running'
+          AND ts.cpu IS NOT NULL
+      ),
+      -- 10. GC 事件与帧窗口重叠检测
+      -- android_garbage_collection_events view 由 prerequisites 中的
+      -- INCLUDE PERFETTO MODULE android.garbage_collection 保证存在（可能为空）
+      gc_frame_overlap AS (
+        SELECT
+          COALESCE(ROUND(SUM(
+            CASE WHEN MIN(gc.gc_ts + gc.gc_dur, ${end_ts}) > MAX(gc.gc_ts, ${start_ts})
+              THEN MIN(gc.gc_ts + gc.gc_dur, ${end_ts}) - MAX(gc.gc_ts, ${start_ts})
+              ELSE 0 END
+          ) / 1e6, 2), 0) as gc_overlap_ms,
+          COUNT(*) as gc_count
+        FROM android_garbage_collection_events gc
+        JOIN thread t ON gc.tid = t.tid
+        JOIN process p ON t.upid = p.upid
+        WHERE (p.name GLOB '${package}*' OR '${package}' = '')
+          AND gc.gc_ts < ${end_ts}
+          AND gc.gc_ts + gc.gc_dur > ${start_ts}
+      ),
+      -- 11. 主线程同步 Binder 与关键 slice 重叠分析
+      binder_sync_main AS (
+        SELECT
+          bt.client_ts,
+          bt.client_dur,
+          bt.server_process
+        FROM android_binder_txns bt
+        WHERE bt.client_tid IN (SELECT tid FROM main_thread_tid)
+          AND bt.is_sync = 1
+          AND bt.client_ts < ${end_ts}
+          AND bt.client_ts + bt.client_dur > ${start_ts}
+      ),
+      binder_frame AS (
+        SELECT
+          ROUND(COALESCE(SUM(client_dur), 0) / 1e6, 2) as sync_total_ms,
+          ROUND(COALESCE(MAX(client_dur), 0) / 1e6, 2) as sync_max_ms,
+          COUNT(*) as sync_count
+        FROM binder_sync_main
+      ),
+      binder_overlap AS (
+        SELECT
+          ROUND(
+            COALESCE(
+              SUM(
+                CASE
+                  WHEN b.client_ts < tsb.slice_end_ns
+                    AND b.client_ts + b.client_dur > tsb.slice_start_ns
+                  THEN
+                    (
+                      CASE
+                        WHEN b.client_ts + b.client_dur < tsb.slice_end_ns THEN b.client_ts + b.client_dur
+                        ELSE tsb.slice_end_ns
+                      END
+                      -
+                      CASE
+                        WHEN b.client_ts > tsb.slice_start_ns THEN b.client_ts
+                        ELSE tsb.slice_start_ns
+                      END
+                    )
+                  ELSE 0
+                END
+              ),
+              0
+            ) / 1e6,
+            2
+          ) as overlap_ms,
+          ROUND(
+            COALESCE(
+              MAX(
+                CASE
+                  WHEN b.client_ts < tsb.slice_end_ns
+                    AND b.client_ts + b.client_dur > tsb.slice_start_ns
+                  THEN
+                    (
+                      CASE
+                        WHEN b.client_ts + b.client_dur < tsb.slice_end_ns THEN b.client_ts + b.client_dur
+                        ELSE tsb.slice_end_ns
+                      END
+                      -
+                      CASE
+                        WHEN b.client_ts > tsb.slice_start_ns THEN b.client_ts
+                        ELSE tsb.slice_start_ns
+                      END
+                    )
+                  ELSE 0
+                END
+              ),
+              0
+            ) / 1e6,
+            2
+          ) as max_overlap_ms,
+          COALESCE(
+            MAX(
+              CASE
+                WHEN b.client_ts < tsb.slice_end_ns
+                  AND b.client_ts + b.client_dur > tsb.slice_start_ns
+                THEN b.server_process
+                ELSE NULL
+              END
+            ),
+            ''
+          ) as overlap_server
+        FROM binder_sync_main b
+        JOIN top_slice_bounds tsb
+      ),
+      -- 12. 综合根因判断
+      analysis AS (
+        SELECT
+          (SELECT dur_ms FROM top_slice) as slice_dur,
+          (SELECT name FROM top_slice) as slice_name,
+          ROUND(((SELECT slice_ts FROM top_slice) - ${start_ts}) / 1e6, 2) as top_slice_offset_ms,
+          (SELECT q1 FROM main_summary) as main_q1,
+          (SELECT q2 FROM main_summary) as main_q2,
+          (SELECT q3 FROM main_summary) as main_q3,
+          (SELECT q4a FROM main_summary) as main_q4a,
+          (SELECT q4b FROM main_summary) as main_q4b,
+          (SELECT q1 FROM render_summary) as render_q1,
+          (SELECT q2 FROM render_summary) as render_q2,
+          (SELECT q3 FROM render_summary) as render_q3,
+          (SELECT q4a FROM render_summary) as render_q4a,
+          (SELECT q4b FROM render_summary) as render_q4b,
+          (SELECT big_avg_freq FROM freq_info) as big_freq,
+          (SELECT big_max_freq FROM freq_info) as big_freq_peak,
+          (SELECT big_min_freq FROM freq_info) as big_freq_min,
+          (SELECT little_avg_freq FROM freq_info) as little_freq,
+          (SELECT little_max_freq FROM freq_info) as little_freq_peak,
+          (SELECT little_min_freq FROM freq_info) as little_freq_min,
+          (SELECT little_run_pct FROM top_slice_cpu_mix) as top_slice_little_pct,
+          (SELECT big_run_pct FROM top_slice_cpu_mix) as top_slice_big_pct,
+          (SELECT runnable_pct FROM top_slice_cpu_mix) as top_slice_runnable_pct,
+          (SELECT blocked_pct FROM top_slice_cpu_mix) as top_slice_blocked_pct,
+          (SELECT top_big_avg_freq_mhz FROM top_slice_freq) as top_big_avg_freq_mhz,
+          (SELECT top_big_max_freq_mhz FROM top_slice_freq) as top_big_max_freq_mhz,
+          (SELECT top_big_min_freq_mhz FROM top_slice_freq) as top_big_min_freq_mhz,
+          (SELECT top_little_avg_freq_mhz FROM top_slice_freq) as top_little_avg_freq_mhz,
+          (SELECT ramp_to_high_ms FROM big_freq_ramp) as ramp_to_high_ms,
+          (SELECT ramp_to_2g_ms FROM big_freq_ramp) as ramp_to_2g_ms,
+          (SELECT overlap_ms FROM binder_overlap) as binder_overlap_ms,
+          (SELECT max_overlap_ms FROM binder_overlap) as binder_max_overlap_ms,
+          (SELECT overlap_server FROM binder_overlap) as binder_overlap_server,
+          (SELECT sync_total_ms FROM binder_frame) as binder_sync_total_ms,
+          (SELECT sync_max_ms FROM binder_frame) as binder_sync_max_ms,
+          (SELECT sync_count FROM binder_frame) as binder_sync_count,
+          (SELECT io_block_ms FROM io_block) as io_block_ms,
+          (SELECT max_sched_ms FROM sched_latency) as max_sched_ms,
+          (SELECT total_sched_ms FROM sched_latency) as total_sched_ms,
+          (SELECT fence_ms FROM gpu_fence) as fence_ms,
+          (SELECT shader_ms FROM shader_compile) as shader_ms,
+          (SELECT shader_count FROM shader_compile) as shader_count,
+          (SELECT gc_overlap_ms FROM gc_frame_overlap) as gc_overlap_ms,
+          (SELECT gc_count FROM gc_frame_overlap) as gc_count,
+          (SELECT big_load_pct FROM cluster_load) as big_load_pct,
+          (SELECT little_load_pct FROM cluster_load) as little_load_pct,
+          ROUND((SELECT vsync_period_ns FROM vsync_config) / 1e6, 2) as frame_budget_ms,
+          ROUND(((SELECT vsync_period_ns FROM vsync_config) / 1e6) * 0.50, 2) as slice_critical_ms,
+          ROUND(MAX(((SELECT vsync_period_ns FROM vsync_config) / 1e6) * 0.20, 2.0), 2) as slice_warning_ms,
+          ROUND(MAX(((SELECT vsync_period_ns FROM vsync_config) / 1e6) * 0.18, 1.5), 2) as gpu_fence_critical_ms,
+          ROUND(MAX(((SELECT vsync_period_ns FROM vsync_config) / 1e6) * 0.06, 0.8), 2) as gpu_fence_warning_ms,
+          ROUND(MAX(((SELECT vsync_period_ns FROM vsync_config) / 1e6) * 0.30, 3.5), 2) as sched_max_critical_ms,
+          ROUND(MAX(((SELECT vsync_period_ns FROM vsync_config) / 1e6) * 0.18, 2.0), 2) as total_sched_critical_ms,
+          ROUND(MAX(((SELECT vsync_period_ns FROM vsync_config) / 1e6) * 0.12, 1.5), 2) as io_block_critical_ms,
+          ROUND(MAX(((SELECT vsync_period_ns FROM vsync_config) / 1e6) * 0.18, 1.5), 2) as binder_overlap_critical_ms,
+          ROUND(MAX(((SELECT vsync_period_ns FROM vsync_config) / 1e6) * 0.35, 2.0), 2) as freq_ramp_critical_ms
+      )
+      , classified AS (
+        SELECT
+          *,
+          CASE
+            -- P0: Buffer Stuffing 管线背压 — 短路跳过线程分析
+            WHEN '${jank_responsibility}' = 'BUFFER_STUFFING'
+              THEN 'buffer_stuffing'
+            -- P1: Binder 同步阻塞（特定可操作，阻塞可能占据 slice 大部分时间）
+            WHEN slice_dur > slice_critical_ms
+              AND binder_overlap_ms >= binder_overlap_critical_ms
+              THEN 'binder_sync_blocking'
+            -- P2: 小核调度（可能导致 3-4x 性能损失，可操作）
+            WHEN slice_dur > slice_critical_ms
+              AND COALESCE(top_slice_little_pct, 0) >= 45
+              THEN 'small_core_placement'
+            -- P3: 关键操作中的调度延迟
+            WHEN slice_dur > slice_critical_ms
+              AND COALESCE(top_slice_runnable_pct, 0) >= 15
+              THEN 'sched_delay_in_slice'
+            -- P4: 重度业务负载（>2x 帧预算）— 即使在满频下也会超时
+            -- 频率/调度等供给侧因素只是放大因素，不是根因
+            WHEN slice_dur > frame_budget_ms * 2.0
+              THEN 'workload_heavy'
+            -- P5: 大核低频（仅适用于边际情况：slice 在 1x-2x 帧预算区间）
+            WHEN slice_dur > slice_critical_ms
+              AND COALESCE(top_slice_big_pct, 0) >= 40
+              AND COALESCE(top_big_avg_freq_mhz, 0) > 0
+              AND COALESCE(top_big_max_freq_mhz, 0) > 0
+              AND top_big_avg_freq_mhz < top_big_max_freq_mhz * 0.55
+              THEN 'big_core_low_freq'
+            -- P6: 频率爬升慢（仅适用于边际情况：slice 在 1x-2x 帧预算区间）
+            WHEN slice_dur > slice_critical_ms
+              AND COALESCE(ramp_to_high_ms, 0) > freq_ramp_critical_ms
+              AND COALESCE(top_slice_offset_ms, 0) <= ramp_to_high_ms
+              THEN 'freq_ramp_slow'
+            -- P7: 工作负载超时兜底（1x-2x 帧预算，无特定供给侧因素）
+            WHEN slice_dur > slice_critical_ms
+              THEN 'workload_heavy'
+            -- P8: GC 导致帧卡顿（GC pause 与帧窗口重叠 > 1ms）
+            WHEN gc_overlap_ms > 1.0
+              THEN 'gc_jank'
+            WHEN max_sched_ms > sched_max_critical_ms
+              OR total_sched_ms > total_sched_critical_ms
+              OR main_q3 > 20
+              THEN 'scheduling_delay'
+            WHEN main_q2 > 50
+              THEN 'small_core_placement'
+            -- Shader 编译（首次渲染特定图形效果时的编译开销）
+            WHEN COALESCE(shader_ms, 0) > gpu_fence_warning_ms
+              THEN 'shader_compile'
+            -- GPU Fence 等待（渲染管线瓶颈，比 CPU 负载更具可操作性）
+            WHEN fence_ms > gpu_fence_warning_ms
+              THEN 'gpu_wait'
+            WHEN big_freq > 0 AND big_freq_peak > 0 AND big_freq < big_freq_peak * 0.45
+              THEN 'big_core_low_freq'
+            WHEN big_load_pct > 90 OR (big_load_pct > 70 AND little_load_pct > 70)
+              THEN 'cpu_load_high'
+            WHEN io_block_ms > io_block_critical_ms OR main_q4a > 20
+              THEN 'blocking_io'
+            WHEN main_q4b > 30
+              THEN 'lock_binder_wait'
+            ELSE 'unknown'
+          END as reason_code
+        FROM analysis
+      )
+      , base_result AS (
+        SELECT
+          CASE
+            -- 优先级1: 主线程有明确耗时操作（相对帧预算）
+            WHEN slice_dur > slice_critical_ms THEN
+              '主线程耗时操作 "' || slice_name || '" 占用 ' || slice_dur || 'ms (帧预算 ' || frame_budget_ms || 'ms)'
+            -- 优先级2: GPU Fence 等待（相对帧预算）
+            WHEN fence_ms > gpu_fence_critical_ms THEN
+              'GPU Fence 等待 ' || ROUND(fence_ms, 1) || 'ms，GPU 繁忙无法及时完成渲染'
+            -- 优先级3: 严重调度延迟（相对帧预算）
+            WHEN max_sched_ms > sched_max_critical_ms THEN
+              '主线程调度延迟严重: 最大等待 ' || ROUND(max_sched_ms, 1) || 'ms'
+            -- 优先级4: 主线程大量等待调度 (Q3 > 20%)
+            WHEN main_q3 > 20 THEN
+              '主线程 CPU 争抢严重 (' || main_q3 || '% 时间在等待调度)'
+            -- 优先级5: 主线程 IO 阻塞（相对帧预算）
+            WHEN io_block_ms > io_block_critical_ms THEN
+              '主线程 IO 阻塞 ' || ROUND(io_block_ms, 1) || 'ms (D 状态)'
+            -- 优先级6: 总调度延迟（相对帧预算）
+            WHEN total_sched_ms > total_sched_critical_ms THEN
+              '主线程 Runnable 累计等待 ' || ROUND(total_sched_ms, 1) || 'ms'
+            -- 优先级7a: 主线程 IO 阻塞 (Q4a > 20%)
+            WHEN main_q4a > 20 THEN
+              '主线程 IO 阻塞 (D/DK 状态)，占比 ' || main_q4a || '%'
+            -- 优先级7b: 主线程锁/Binder等待 (Q4b > 30%)
+            WHEN main_q4b > 30 THEN
+              '主线程锁/Binder 等待 (S/I 状态)，占比 ' || main_q4b || '%'
+            -- 优先级8: RenderThread 休眠 (Q4 > 50%)
+            WHEN (render_q4a + render_q4b) > 50 THEN
+              'RenderThread 长时间休眠 (' || (render_q4a + render_q4b) || '%)，等待主线程或 GPU'
+            -- 优先级9: 主线程在小核运行 (Q2 > 50%)
+            WHEN main_q2 > 50 THEN
+              '主线程被调度到小核 (' || main_q2 || '%)，CPU 能力不足'
+            -- 优先级10: CPU 频率问题
+            WHEN big_freq < 1200 AND big_freq > 0 THEN
+              '大核频率过低 (' || big_freq || 'MHz)，可能触发温控限频'
+            -- 优先级11: 大核簇负载过高 (>90%)
+            WHEN big_load_pct > 90 THEN
+              '大核簇负载 ' || ROUND(big_load_pct, 0) || '%，CPU 资源严重不足'
+            -- 优先级12: GPU Fence 中等延迟（相对帧预算）
+            WHEN fence_ms > gpu_fence_warning_ms THEN
+              'GPU Fence 等待 ' || ROUND(fence_ms, 1) || 'ms'
+            -- 优先级13: CPU 整体负载高
+            WHEN big_load_pct > 70 AND little_load_pct > 70 THEN
+              'CPU 整体负载高 (大核 ' || ROUND(big_load_pct, 0) || '%, 小核 ' || ROUND(little_load_pct, 0) || '%)'
+            -- 优先级14: 有中等耗时操作（相对帧预算）
+            WHEN slice_dur > slice_warning_ms THEN
+              '主线程操作 "' || slice_name || '" 耗时 ' || slice_dur || 'ms'
+            -- 默认
+            ELSE '帧耗时 ${dur_ms}ms 超过 VSync 周期(' || frame_budget_ms || 'ms)'
+          END as primary_cause,
+          CASE
+            WHEN reason_code = 'buffer_stuffing' THEN
+              'Buffer Stuffing: 管线背压，帧耗时 ' || ${dur_ms} || 'ms，BufferQueue 积压导致跳帧（非 App 问题）'
+            WHEN reason_code = 'binder_sync_blocking' THEN
+              'Binder 同步阻塞：关键操作与同步Binder重叠 ' || binder_overlap_ms || 'ms（累计 ' ||
+              binder_sync_total_ms || 'ms' ||
+              CASE
+                WHEN COALESCE(binder_overlap_server, '') != '' THEN '，对端 ' || binder_overlap_server || ''
+                ELSE ''
+              END || '）'
+            WHEN reason_code = 'small_core_placement' THEN
+              '线程更多跑在小核：关键操作小核运行占比 ' || COALESCE(top_slice_little_pct, 0) ||
+              '%（大核占比 ' || COALESCE(top_slice_big_pct, 0) || '%）'
+            WHEN reason_code = 'sched_delay_in_slice' THEN
+              '调度延迟：关键操作中 Runnable 等待占比 ' || COALESCE(top_slice_runnable_pct, 0) ||
+              '%，主线程最大调度等待 ' || COALESCE(max_sched_ms, 0) || 'ms'
+            WHEN reason_code = 'big_core_low_freq' THEN
+              '大核低频：关键操作大核运行占比 ' || COALESCE(top_slice_big_pct, 0) ||
+              '%，但平均频率仅 ' || COALESCE(top_big_avg_freq_mhz, big_freq) || 'MHz（片内峰值 ' ||
+              COALESCE(top_big_max_freq_mhz, big_freq_peak) || 'MHz）'
+            WHEN reason_code = 'freq_ramp_slow' THEN
+              '频率爬升慢：帧开始后 ' || COALESCE(ramp_to_high_ms, 0) ||
+              'ms 才升到高频，关键操作起点 +' || COALESCE(top_slice_offset_ms, 0) || 'ms'
+            WHEN reason_code = 'workload_heavy' THEN
+              CASE
+                WHEN slice_name GLOB '*RV*Prefetch*' OR slice_name GLOB '*OnBind*' OR slice_name GLOB '*Adapter*bind*' OR slice_name GLOB '*bind*'
+                  THEN '业务负载重：列表预取/绑定逻辑在主线程串行执行 ' || slice_dur || 'ms（超帧预算 ' || ROUND(slice_dur / NULLIF(frame_budget_ms, 0), 1) || '倍）'
+                WHEN COALESCE(ramp_to_high_ms, 0) > freq_ramp_critical_ms
+                  THEN '业务负载重：操作耗时 ' || slice_dur || 'ms（超帧预算 ' || ROUND(slice_dur / NULLIF(frame_budget_ms, 0), 1) || '倍），频率爬升 ' || ramp_to_high_ms || 'ms 为次要加剧因素'
+                ELSE '业务负载重：主线程操作耗时 ' || slice_dur || 'ms（超帧预算 ' || ROUND(slice_dur / NULLIF(frame_budget_ms, 0), 1) || '倍）'
+              END
+            WHEN reason_code = 'scheduling_delay' THEN
+              '调度延迟：主线程 Runnable 累计 ' || COALESCE(total_sched_ms, 0) ||
+              'ms（最大 ' || COALESCE(max_sched_ms, 0) || 'ms）'
+            WHEN reason_code = 'cpu_load_high' THEN
+              'CPU 负载高：大核负载 ' || COALESCE(big_load_pct, 0) ||
+              '%，小核负载 ' || COALESCE(little_load_pct, 0) || '%'
+            WHEN reason_code = 'blocking_io' THEN
+              'IO 阻塞：主线程不可中断睡眠(D/DK) ' || COALESCE(io_block_ms, 0) || 'ms，Q4a 占比 ' || COALESCE(main_q4a, 0) || '%'
+            WHEN reason_code = 'lock_binder_wait' THEN
+              '锁/Binder 等待：主线程可中断睡眠(S/I)，Q4b 占比 ' || COALESCE(main_q4b, 0) || '%'
+            WHEN reason_code = 'shader_compile' THEN
+              'Shader 编译：RenderThread 上着色器编译耗时 ' || COALESCE(shader_ms, 0) || 'ms（' || COALESCE(shader_count, 0) || ' 次），首次渲染或新视觉效果触发'
+            WHEN reason_code = 'gpu_wait' THEN
+              'GPU 等待：RenderThread/GPU Fence 累计等待 ' || COALESCE(fence_ms, 0) || 'ms'
+            WHEN reason_code = 'gc_jank' THEN
+              'GC 暂停：帧窗口内 GC 重叠 ' || COALESCE(gc_overlap_ms, 0) || 'ms（' || COALESCE(gc_count, 0) || ' 次 GC）'
+            ELSE NULL
+          END as deep_reason,
+          CASE
+            WHEN reason_code = 'buffer_stuffing' THEN '非 App 问题：BufferQueue 管线背压导致跳帧。检查帧率设置是否匹配显示刷新率，或优化渲染管线吞吐'
+            WHEN reason_code = 'binder_sync_blocking' THEN '优化方向：减少主线程同步 Binder（异步化/批量化/结果缓存）并压缩关键路径 IPC'
+            WHEN reason_code = 'small_core_placement' THEN '优化方向：保证关键滚动路径优先使用大核，减少后台线程对主线程的抢占'
+            WHEN reason_code = 'sched_delay_in_slice' OR reason_code = 'scheduling_delay' THEN '优化方向：降低同窗并发与高优线程竞争，缩短主线程 Runnable 等待'
+            WHEN reason_code = 'big_core_low_freq' THEN '优化方向：在输入/滚动前预拉频，避免大核低频执行关键 UI 热路径'
+            WHEN reason_code = 'freq_ramp_slow' THEN '优化方向：使用 touch/scroll boost 提前拉频，减少频率爬升滞后'
+            WHEN reason_code = 'workload_heavy' THEN
+              CASE
+                WHEN slice_name GLOB '*RV*Prefetch*' OR slice_name GLOB '*OnBind*' OR slice_name GLOB '*Adapter*bind*' OR slice_name GLOB '*bind*'
+                  THEN '优化方向：拆分 RV Prefetch/OnBind 重逻辑，预计算和缓存绑定数据，避免主线程串行重活'
+                ELSE '优化方向：把关键帧内重逻辑拆分到后台并做结果复用，缩短主线程单次执行时长'
+              END
+            WHEN reason_code = 'cpu_load_high' THEN '优化方向：降低 CPU 总负载并限制后台并发，优先保障 UI 与 RenderThread 预算'
+            WHEN reason_code = 'blocking_io' THEN '优化方向：排查主线程 IO 操作（文件读写/页缺失/磁盘同步），移至后台线程或使用异步 IO'
+            WHEN reason_code = 'lock_binder_wait' THEN '优化方向：减少主线程同步等待（Binder/锁/futex），缩短临界区和同步链路'
+            WHEN reason_code = 'shader_compile' THEN '优化方向：使用 PrecompiledShaders / Shader Warm-up 在启动时预编译着色器，避免滑动时动态编译'
+            WHEN reason_code = 'gpu_wait' THEN '优化方向：降低 draw 复杂度/overdraw，减少 GPU Fence 等待'
+            WHEN reason_code = 'gc_jank' THEN '优化方向：减少帧渲染路径上的对象分配，使用对象池化/预分配，避免 GC 暂停重叠关键帧'
+            ELSE '优化方向：扩大同窗样本做聚类，确认该慢原因是否稳定复现'
+          END as optimization_hint,
+          reason_code,
+          CASE
+            WHEN reason_code = 'buffer_stuffing' THEN 'Buffer Stuffing 管线背压（jank_type=${jank_type}）'
+            WHEN reason_code = 'binder_sync_blocking' THEN '同步 Binder 重叠 ' || COALESCE(binder_overlap_ms, 0) || 'ms'
+            WHEN reason_code = 'small_core_placement' THEN '关键操作小核占比 ' || COALESCE(top_slice_little_pct, 0) || '%'
+            WHEN reason_code = 'sched_delay_in_slice' THEN '关键操作 Runnable 占比 ' || COALESCE(top_slice_runnable_pct, 0) || '%'
+            WHEN reason_code = 'big_core_low_freq' THEN '关键操作大核频率 ' || COALESCE(top_big_avg_freq_mhz, big_freq) || 'MHz'
+            WHEN reason_code = 'freq_ramp_slow' THEN '高频拉升耗时 ' || COALESCE(ramp_to_high_ms, 0) || 'ms'
+            WHEN reason_code = 'workload_heavy' THEN '操作 "' || COALESCE(slice_name, 'unknown') || '" 耗时 ' || COALESCE(slice_dur, 0) || 'ms（超帧预算 ' || ROUND(COALESCE(slice_dur, 0) / NULLIF(frame_budget_ms, 0), 1) || 'x）' ||
+              CASE WHEN COALESCE(ramp_to_high_ms, 0) > freq_ramp_critical_ms THEN '，频率爬升 ' || ramp_to_high_ms || 'ms 加剧' ELSE '' END
+            WHEN reason_code = 'gc_jank' THEN 'GC 重叠 ' || COALESCE(gc_overlap_ms, 0) || 'ms（' || COALESCE(gc_count, 0) || ' 次）'
+            WHEN reason_code = 'shader_compile' THEN 'Shader 编译 ' || COALESCE(shader_ms, 0) || 'ms（' || COALESCE(shader_count, 0) || ' 次）'
+            WHEN fence_ms > gpu_fence_warning_ms THEN 'GPU Fence 等待 ' || ROUND(fence_ms, 1) || 'ms'
+            WHEN total_sched_ms > (total_sched_critical_ms * 0.5) THEN '调度等待累计 ' || ROUND(total_sched_ms, 1) || 'ms'
+            WHEN big_load_pct > 70 THEN '大核负载 ' || ROUND(big_load_pct, 0) || '%'
+            WHEN big_freq > 0 AND big_freq < 1500 THEN '大核平均频率 ' || big_freq || 'MHz'
+            WHEN main_q2 > 30 THEN '小核运行占比 ' || main_q2 || '%'
+            ELSE NULL
+          END as secondary_info,
+          CASE
+            WHEN slice_dur > slice_critical_ms THEN '高'
+            WHEN gc_overlap_ms > 1.0 THEN '高'
+            WHEN fence_ms > gpu_fence_critical_ms THEN '高'
+            WHEN max_sched_ms > sched_max_critical_ms THEN '高'
+            WHEN main_q3 > 20 THEN '高'
+            WHEN io_block_ms > io_block_critical_ms THEN '高'
+            WHEN total_sched_ms > total_sched_critical_ms THEN '高'
+            WHEN big_load_pct > 90 THEN '高'
+            WHEN COALESCE(shader_ms, 0) > gpu_fence_warning_ms THEN '高'
+            WHEN main_q4a > 20 OR main_q4b > 30 THEN '中'
+            WHEN fence_ms > gpu_fence_warning_ms THEN '中'
+            WHEN big_load_pct > 70 AND little_load_pct > 70 THEN '中'
+            WHEN slice_dur > slice_warning_ms THEN '中'
+            ELSE '低'
+          END as confidence,
+          CASE
+            -- SF 合成超时短路：jank_responsibility 指向 SF，App 侧指标不相关
+            WHEN '${jank_responsibility}' = 'SF' THEN 'sf_composition'
+            WHEN slice_dur > slice_critical_ms THEN 'slice'
+            WHEN fence_ms > gpu_fence_critical_ms THEN 'gpu_fence'
+            WHEN max_sched_ms > sched_max_critical_ms THEN 'sched_latency'
+            WHEN main_q3 > 20 THEN 'cpu_contention'
+            WHEN io_block_ms > io_block_critical_ms THEN 'io_blocking'
+            WHEN total_sched_ms > total_sched_critical_ms THEN 'sched_latency'
+            WHEN main_q4a > 20 THEN 'io_blocking'
+            WHEN main_q4b > 30 THEN 'blocking'
+            -- RenderThread 负载过重：RT 主动运行，非等待 GPU/SF
+            WHEN render_q4a < 10 AND render_q4b < 20 AND COALESCE(shader_ms, 0) <= gpu_fence_warning_ms
+              AND fence_ms <= gpu_fence_warning_ms
+              THEN 'render_heavy'
+            WHEN (render_q4a + render_q4b) > 50 THEN 'render_wait'
+            WHEN COALESCE(shader_ms, 0) > gpu_fence_warning_ms THEN 'shader_compile'
+            WHEN gc_overlap_ms > 1.0 THEN 'gc_pause'
+            WHEN main_q2 > 50 THEN 'small_core'
+            WHEN big_freq < 1200 AND big_freq > 0 THEN 'freq_limit'
+            WHEN big_load_pct > 90 THEN 'cpu_overload'
+            WHEN fence_ms > gpu_fence_warning_ms THEN 'gpu_fence'
+            WHEN big_load_pct > 70 AND little_load_pct > 70 THEN 'cpu_overload'
+            ELSE 'unknown'
+          END as cause_type,
+          slice_name,
+          slice_dur,
+          frame_budget_ms,
+          ${dur_ms} as frame_dur_ms,
+          '${jank_type}' as jank_type,
+          '${jank_responsibility}' as jank_responsibility,
+          max_sched_ms,
+          total_sched_ms,
+          main_q2,
+          main_q3,
+          main_q4a,
+          main_q4b,
+          big_freq,
+          big_freq_peak,
+          top_slice_little_pct,
+          top_slice_big_pct,
+          top_slice_runnable_pct,
+          top_big_avg_freq_mhz,
+          top_big_max_freq_mhz,
+          ramp_to_high_ms,
+          binder_overlap_ms,
+          binder_sync_total_ms,
+          big_load_pct,
+          little_load_pct,
+          io_block_ms,
+          render_q4a,
+          render_q4b,
+          fence_ms,
+          shader_ms,
+          shader_count,
+          sched_max_critical_ms,
+          total_sched_critical_ms,
+          io_block_critical_ms
+        FROM classified
+      )
+      SELECT
+        primary_cause,
+        deep_reason,
+        optimization_hint,
+        reason_code,
+        secondary_info,
+        confidence,
+        cause_type,
+        slice_name,
+        slice_dur,
+        frame_budget_ms,
+        main_q3 as main_q3_pct,
+        main_q4a as main_q4a_pct,
+        main_q4b as main_q4b_pct,
+        render_q4a as render_q4a_pct,
+        render_q4b as render_q4b_pct,
+        max_sched_ms as main_max_sched_ms,
+        io_block_ms as main_io_block_ms,
+        fence_ms as gpu_fence_ms,
+        frame_dur_ms,
+        jank_type,
+        CASE
+          WHEN cause_type IN ('slice', 'blocking', 'io_blocking') THEN 'trigger'
+          WHEN cause_type IN ('sched_latency', 'cpu_contention', 'small_core', 'freq_limit', 'cpu_overload') THEN 'supply'
+          WHEN cause_type IN ('gpu_fence', 'render_wait', 'shader_compile') THEN 'amplification'
+          WHEN cause_type = 'gc_pause' THEN 'trigger'
+          WHEN cause_type = 'sf_composition' THEN 'amplification'
+          WHEN cause_type = 'render_heavy' THEN 'trigger'
+          ELSE 'unknown'
+        END as mechanism_group,
+        CASE
+          WHEN reason_code = 'buffer_stuffing' THEN 'none'
+          WHEN reason_code = 'sf_composition_slow' THEN 'none'
+          WHEN reason_code = 'thermal_throttling' THEN 'thermal_throttle'
+          WHEN reason_code IN ('binder_sync_blocking', 'blocking_io', 'lock_binder_wait', 'binder_timeout') THEN 'blocking_wait'
+          WHEN reason_code = 'gc_jank' THEN 'gc_pause'
+          WHEN reason_code = 'gc_pressure_cascade' THEN 'gc_pause'
+          WHEN reason_code = 'small_core_placement' THEN 'core_placement'
+          WHEN reason_code IN ('big_core_low_freq', 'freq_ramp_slow', 'cpu_max_limited') THEN 'frequency_insufficient'
+          WHEN reason_code IN ('sched_delay_in_slice', 'scheduling_delay') THEN 'scheduling_delay'
+          WHEN reason_code IN ('cpu_load_high', 'cpu_saturation') THEN 'load_high'
+          WHEN reason_code = 'main_thread_file_io' THEN 'blocking_wait'
+          WHEN reason_code = 'render_thread_heavy' THEN 'none'
+          WHEN reason_code = 'shader_compile' THEN 'none'
+          WHEN reason_code = 'workload_heavy' THEN 'none'
+          WHEN io_block_ms > io_block_critical_ms OR main_q4a > 20 OR main_q4b > 30 THEN 'blocking_wait'
+          WHEN big_freq < 1200 AND big_freq > 0 THEN 'frequency_insufficient'
+          WHEN main_q2 > 50 THEN 'core_placement'
+          WHEN max_sched_ms > sched_max_critical_ms OR total_sched_ms > total_sched_critical_ms OR main_q3 > 20 THEN 'scheduling_delay'
+          WHEN big_load_pct > 90 OR (big_load_pct > 70 AND little_load_pct > 70) THEN 'load_high'
+          WHEN cause_type = 'freq_limit' THEN 'frequency_insufficient'
+          WHEN cause_type = 'small_core' THEN 'core_placement'
+          WHEN cause_type IN ('sched_latency', 'cpu_contention') THEN 'scheduling_delay'
+          WHEN cause_type = 'cpu_overload' THEN 'load_high'
+          WHEN cause_type IN ('blocking', 'io_blocking') THEN 'blocking_wait'
+          ELSE 'none'
+        END as supply_constraint,
+        CASE
+          WHEN reason_code = 'buffer_stuffing' THEN 'buffer_pipeline'
+          WHEN reason_code = 'sf_composition_slow' THEN 'sf_consumer'
+          WHEN cause_type IN ('slice', 'blocking', 'io_blocking', 'sched_latency', 'cpu_contention', 'small_core', 'freq_limit', 'cpu_overload', 'gc_pause', 'render_heavy') THEN 'app_producer'
+          WHEN cause_type IN ('gpu_fence', 'render_wait', 'shader_compile', 'sf_composition') THEN 'sf_consumer'
+          ELSE 'unknown'
+        END as trigger_layer,
+        CASE
+          WHEN reason_code = 'buffer_stuffing' THEN 'buffer_queue_backpressure'
+          WHEN reason_code = 'sf_composition_slow' THEN 'sf_consumer_backpressure'
+          WHEN cause_type = 'gpu_fence' THEN 'gpu_fence_wait'
+          WHEN cause_type = 'shader_compile' THEN 'shader_compile_stall'
+          WHEN cause_type IN ('render_wait', 'sf_composition') THEN 'render_pipeline_wait'
+          WHEN cause_type = 'render_heavy' THEN 'app_deadline_miss'
+          WHEN jank_responsibility = 'SF' THEN 'sf_consumer_backpressure'
+          WHEN jank_responsibility = 'APP' THEN 'app_deadline_miss'
+          ELSE 'unknown'
+        END as amplification_path
+      FROM base_result
+    save_as: root_cause
+    optional: true
+
+  - id: frame_diagnosis
+    type: diagnostic
+    name: "帧诊断"
+    display:
+      level: detail
+      layer: deep
+      title: "详细诊断"
+    inputs: [quadrant_data, binder_data, freq_data, main_slices, render_slices, freq_timeline, lock_data, gc_data, io_data, root_cause, sched_data, migration_data, gpu_data, binder_blocking_data, throttling_data, cluster_load_data, page_fault_data, sf_data, gpu_freq_data, vsync_data, pipeline_data]
+    rules:
+      # ===== 最高优先级：根因分析总结 =====
+      - condition: "root_cause?.data?.[0]?.primary_cause"
+        severity: critical
+        diagnosis: "${root_cause.data[0].primary_cause}"
+        confidence: "${root_cause.data[0].confidence === '高' ? 'high' : root_cause.data[0].confidence === '中' ? 'medium' : 'low'}"
+        suggestions:
+          - "${root_cause.data[0].secondary_info || '查看下方详细数据分析具体原因'}"
+
+      # ===== 高优先级：锁竞争 =====
+      - condition: "lock_data?.data?.length > 0 && lock_data.data[0]?.wait_ms > 1"
+        severity: critical
+        diagnosis: "锁竞争等待 ${lock_data.data[0].wait_ms}ms (${lock_data.data[0].blocking_method})"
+        confidence: high
+        suggestions:
+          - "检查持锁线程是否在做耗时操作"
+          - "考虑减少锁粒度或使用无锁数据结构"
+
+      - condition: "lock_data?.data?.length > 0 && lock_data.data[0]?.main_blocked === 1"
+        severity: critical
+        diagnosis: "主线程被锁阻塞 (等待 ${lock_data.data[0].blocking_thread_name})"
+        confidence: high
+        suggestions:
+          - "避免在持锁时做 Binder/IO 操作"
+          - "考虑使用异步锁或拆分锁"
+
+      # ===== 高优先级：IO 阻塞 =====
+      - condition: "io_data?.data?.length > 0 && io_data.data[0]?.total_ms > 3"
+        severity: critical
+        diagnosis: "IO 阻塞 ${io_data.data[0].total_ms}ms (${io_data.data[0].thread_name}, ${io_data.data[0].io_cause})"
+        confidence: high
+        suggestions:
+          - "将文件/数据库 IO 移到后台线程"
+          - "检查是否有不必要的同步 IO 操作"
+
+      - condition: "io_data?.data?.length > 0 && io_data.data[0]?.total_ms > 1"
+        severity: warning
+        diagnosis: "${io_data.data[0].thread_name} IO 等待 ${io_data.data[0].total_ms}ms"
+        confidence: high
+        suggestions:
+          - "检查帧期间是否有磁盘读写操作"
+          - "考虑使用内存映射或预加载"
+
+      # ===== 高优先级：GC 影响 =====
+      - condition: "gc_data?.data?.length > 0 && gc_data.data.reduce((s, g) => s + (g.overlap_ms || 0), 0) > 3"
+        severity: critical
+        diagnosis: "GC 严重影响帧渲染：总重叠 ${gc_data.data.reduce((s, g) => s + (g.overlap_ms || 0), 0).toFixed(1)}ms"
+        confidence: high
+        suggestions:
+          - "减少帧期间的对象分配"
+          - "检查是否有大对象频繁创建"
+          - "考虑对象池化或预分配"
+
+      - condition: "gc_data?.data?.length > 0 && gc_data.data[0]?.overlap_ms > 1"
+        severity: warning
+        diagnosis: "GC (${gc_data.data[0].gc_type}) 与帧重叠 ${gc_data.data[0].overlap_ms}ms"
+        confidence: high
+        suggestions:
+          - "减少短生命周期对象的分配"
+          - "避免在 onDraw/onLayout 中创建对象"
+
+      # ===== 高优先级：调度延迟 =====
+      - condition: "sched_data?.data?.length > 0 && sched_data.data[0]?.max_latency_ms > 5"
+        severity: critical
+        diagnosis: "${sched_data.data[0].thread_name} 调度延迟严重: 最大 ${sched_data.data[0].max_latency_ms}ms"
+        confidence: high
+        suggestions:
+          - "检查系统是否有高优先级进程抢占 CPU"
+          - "考虑提高 UI 线程优先级"
+          - "检查后台任务是否过于密集"
+
+      - condition: "sched_data?.data?.length > 0 && sched_data.data[0]?.total_runnable_ms > 3"
+        severity: warning
+        diagnosis: "${sched_data.data[0].thread_name} Runnable 等待 ${sched_data.data[0].total_runnable_ms}ms (${sched_data.data[0].runnable_count}次)"
+        confidence: high
+        suggestions:
+          - "系统 CPU 资源紧张"
+          - "检查是否有密集计算任务"
+
+      # ===== 高优先级：大小核迁移 =====
+      - condition: "migration_data?.data?.length > 0 && migration_data.data[0]?.big_to_little > 2"
+        severity: warning
+        diagnosis: "${migration_data.data[0].thread_name} 从大核迁移到小核 ${migration_data.data[0].big_to_little}次"
+        confidence: high
+        suggestions:
+          - "检查系统温控策略是否过于激进"
+          - "考虑绑定 UI 线程到大核"
+
+      - condition: "migration_data?.data?.length > 0 && migration_data.data[0]?.big_core_pct < 30"
+        severity: warning
+        diagnosis: "${migration_data.data[0].thread_name} 大核运行占比仅 ${migration_data.data[0].big_core_pct}%"
+        confidence: high
+        suggestions:
+          - "UI 线程未能获得足够大核资源"
+          - "检查调度器配置"
+
+      # ===== 高优先级：GPU 操作 =====
+      - condition: "gpu_data?.data?.find(g => g.operation === 'GPU Fence Wait')?.total_ms > 3"
+        severity: critical
+        diagnosis: "GPU Fence 等待 ${gpu_data.data.find(g => g.operation === 'GPU Fence Wait')?.total_ms}ms"
+        confidence: high
+        suggestions:
+          - "GPU 繁忙，无法及时完成上一帧"
+          - "检查是否有复杂的 GPU 着色器"
+          - "减少过度绘制"
+
+      - condition: "gpu_data?.data?.find(g => g.operation === 'EGL SwapBuffers')?.max_ms > 5"
+        severity: warning
+        diagnosis: "EGL SwapBuffers 耗时 ${gpu_data.data.find(g => g.operation === 'EGL SwapBuffers')?.max_ms}ms"
+        confidence: high
+        suggestions:
+          - "帧缓冲交换延迟，可能是 GPU/SF 瓶颈"
+          - "检查三缓冲是否正常"
+
+      # ===== 高优先级：Binder 阻塞 =====
+      - condition: "binder_blocking_data?.data?.length > 0 && binder_blocking_data.data[0]?.max_block_ms > 5"
+        severity: critical
+        diagnosis: "Binder 同步调用阻塞 ${binder_blocking_data.data[0].max_block_ms}ms (${binder_blocking_data.data[0].server_process})"
+        confidence: high
+        suggestions:
+          - "将 Binder 调用移到后台线程"
+          - "使用 oneway Binder 调用"
+          - "检查服务端是否有性能问题"
+
+      - condition: "binder_blocking_data?.data?.length > 0 && binder_blocking_data.data[0]?.total_block_ms > 2"
+        severity: warning
+        diagnosis: "Binder 调用总阻塞 ${binder_blocking_data.data[0].total_block_ms}ms (${binder_blocking_data.data[0].call_count}次)"
+        confidence: high
+        suggestions:
+          - "减少帧期间的 Binder 调用次数"
+          - "考虑批量处理或缓存"
+
+      # ===== 高优先级：CPU 限频 =====
+      - condition: "Boolean(throttling_data?.data?.find(t => t.core_type === 'big' && t.throttle_detected === 1 && (t.freq_drop_pct || 0) > 20 && (t.max_freq_mhz || 0) > (t.min_freq_mhz || 0)))"
+        severity: critical
+        diagnosis: "检测到 CPU 限频: 大核最低 ${throttling_data.data.find(t => t.core_type === 'big' && t.throttle_detected === 1)?.min_freq_mhz}MHz（峰值 ${throttling_data.data.find(t => t.core_type === 'big' && t.throttle_detected === 1)?.max_freq_mhz}MHz，降幅 ${throttling_data.data.find(t => t.core_type === 'big' && t.throttle_detected === 1)?.freq_drop_pct}%）"
+        confidence: high
+        suggestions:
+          - "设备温度过高触发限频"
+          - "减少持续高负载任务"
+          - "检查散热状况"
+
+      - condition: "Boolean(throttling_data?.data?.find(t => t.core_type === 'big' && (t.freq_drop_pct || 0) > 20))"
+        severity: warning
+        diagnosis: "帧期间大核降频 ${throttling_data.data.find(t => t.core_type === 'big')?.freq_drop_pct}%"
+        confidence: high
+        suggestions:
+          - "CPU 频率不稳定影响性能"
+          - "检查功耗管理策略"
+
+      # ===== 高优先级：CPU 簇负载 =====
+      - condition: "cluster_load_data?.data?.find(c => c.cluster === '大核簇')?.load_pct > 90"
+        severity: critical
+        diagnosis: "大核簇负载 ${cluster_load_data.data.find(c => c.cluster === '大核簇')?.load_pct}%，接近跑满"
+        confidence: high
+        suggestions:
+          - "大核资源严重不足"
+          - "检查是否有后台密集计算任务"
+          - "考虑优化或推迟非关键任务"
+
+      - condition: "cluster_load_data?.data?.find(c => c.cluster === '小核簇')?.load_pct > 95"
+        severity: warning
+        diagnosis: "小核簇负载 ${cluster_load_data.data.find(c => c.cluster === '小核簇')?.load_pct}%，几乎跑满"
+        confidence: high
+        suggestions:
+          - "系统整体负载很高"
+          - "后台任务可能挤占资源"
+
+      - condition: "cluster_load_data?.data?.find(c => c.cluster === '大核簇')?.load_pct > 70 && cluster_load_data?.data?.find(c => c.cluster === '小核簇')?.load_pct > 70"
+        severity: warning
+        diagnosis: "CPU 整体负载高: 大核 ${cluster_load_data.data.find(c => c.cluster === '大核簇')?.load_pct}%, 小核 ${cluster_load_data.data.find(c => c.cluster === '小核簇')?.load_pct}%"
+        confidence: high
+        suggestions:
+          - "系统 CPU 资源紧张"
+          - "多任务竞争导致调度延迟"
+
+      - condition: "cluster_load_data?.data?.find(c => c.cluster === '大核簇')?.max_single_core_pct > 95"
+        severity: info
+        diagnosis: "大核簇中有核心接近 100% (${cluster_load_data.data.find(c => c.cluster === '大核簇')?.max_single_core_pct}%)"
+        confidence: medium
+        suggestions:
+          - "可能有单线程密集任务"
+          - "检查是否有热点线程"
+
+      # ===== 高优先级：页面错误 =====
+      - condition: "page_fault_data?.data?.length > 0 && page_fault_data.data[0]?.total_ms > 2"
+        severity: critical
+        diagnosis: "${page_fault_data.data[0].thread_name} 内存操作阻塞 ${page_fault_data.data[0].total_ms}ms (${page_fault_data.data[0].fault_type})"
+        confidence: high
+        suggestions:
+          - "触发页面错误或内存回收"
+          - "预加载可能需要的数据"
+          - "检查内存压力"
+
+      - condition: "page_fault_data?.data?.find(p => p.fault_type === 'memory_reclaim')?.total_ms > 1"
+        severity: warning
+        diagnosis: "系统内存回收导致阻塞 ${page_fault_data.data.find(p => p.fault_type === 'memory_reclaim')?.total_ms}ms"
+        confidence: high
+        suggestions:
+          - "系统内存紧张"
+          - "检查应用内存使用"
+
+      # ===== 中优先级：SurfaceFlinger =====
+      - condition: "sf_data?.data?.find(s => s.composition_type === 'Composite')?.total_ms > 3"
+        severity: warning
+        diagnosis: "SurfaceFlinger 合成耗时 ${sf_data.data.find(s => s.composition_type === 'Composite')?.total_ms}ms"
+        confidence: medium
+        suggestions:
+          - "系统合成层可能是瓶颈"
+          - "检查图层数量和复杂度"
+
+      # ===== 中优先级：GPU 频率 =====
+      - condition: "gpu_freq_data?.data?.length > 0 && gpu_freq_data.data[0]?.low_freq_pct > 50"
+        severity: warning
+        diagnosis: "GPU 低频运行占比 ${gpu_freq_data.data[0].low_freq_pct}%"
+        confidence: medium
+        suggestions:
+          - "GPU 未能提升频率"
+          - "检查 GPU 功耗策略"
+
+      # ===== 中优先级：VSync 对齐 =====
+      - condition: "vsync_data?.data?.find(v => v.metric === '截止时间')?.value?.includes('超时')"
+        severity: warning
+        diagnosis: "帧未能在 VSync 前完成: ${vsync_data.data.find(v => v.metric === '截止时间')?.value}"
+        confidence: high
+        suggestions:
+          - "帧渲染超过 VSync 周期"
+          - "需要优化帧渲染时间"
+
+      # ===== 信息级：渲染流水线分解 =====
+      - condition: "pipeline_data?.data?.find(p => p.stage?.includes('主线程'))?.pct > 70"
+        severity: info
+        diagnosis: "主线程占用帧时间 ${pipeline_data.data.find(p => p.stage?.includes('主线程'))?.pct}%"
+        confidence: high
+        suggestions:
+          - "主线程是主要瓶颈"
+          - "检查主线程耗时操作"
+
+      - condition: "pipeline_data?.data?.find(p => p.stage?.includes('RenderThread'))?.pct > 60"
+        severity: info
+        diagnosis: "RenderThread 占用帧时间 ${pipeline_data.data.find(p => p.stage?.includes('RenderThread'))?.pct}%"
+        confidence: high
+        suggestions:
+          - "渲染是主要瓶颈"
+          - "检查 GPU 操作和绘制复杂度"
+
+      # ===== 高优先级：Binder 调用 =====
+      - condition: "binder_data?.data?.length > 0 && binder_data.data[0]?.dur_ms > 2"
+        severity: warning
+        diagnosis: "Binder 调用耗时 ${binder_data.data[0].dur_ms}ms (${binder_data.data[0].interface})"
+        confidence: high
+        suggestions:
+          - "检查是否可以异步调用"
+          - "考虑使用缓存减少调用次数"
+
+      # ===== 四象限分析（使用 .find() 查找特定象限）=====
+      # Q3 等待调度 - 说明 CPU 繁忙
+      - condition: "quadrant_data?.data?.find(q => q.quadrant?.includes('Q3'))?.percentage > 15"
+        severity: warning
+        diagnosis: "主线程 Runnable 等待 ${quadrant_data.data.find(q => q.quadrant?.includes('Q3'))?.percentage}%"
+        confidence: high
+        suggestions:
+          - "CPU 资源争抢，检查后台任务"
+          - "考虑提高线程优先级"
+
+      # Q4 休眠阻塞 - 说明在等待 IO 或锁
+      - condition: "quadrant_data?.data?.find(q => q.quadrant?.includes('MainThread') && q.quadrant?.includes('Q4'))?.percentage > 40"
+        severity: warning
+        diagnosis: "主线程休眠/阻塞时间占比 ${quadrant_data.data.find(q => q.quadrant?.includes('MainThread') && q.quadrant?.includes('Q4'))?.percentage}%"
+        confidence: high
+        suggestions:
+          - "检查是否有 IO 操作或锁等待"
+          - "考虑使用异步 IO"
+
+      # Q2 小核运行占比高 - 说明调度可能有问题
+      - condition: "quadrant_data?.data?.find(q => q.quadrant?.includes('MainThread') && q.quadrant?.includes('Q2'))?.percentage > 60"
+        severity: info
+        diagnosis: "主线程主要运行在小核 (${quadrant_data.data.find(q => q.quadrant?.includes('MainThread') && q.quadrant?.includes('Q2'))?.percentage}%)"
+        confidence: medium
+        suggestions:
+          - "检查系统温控是否限制大核"
+          - "考虑提高线程优先级"
+
+      # ===== 主线程耗时操作 =====
+      - condition: "main_slices?.data?.length > 0 && main_slices.data[0]?.dur_ms > 5"
+        severity: warning
+        diagnosis: "主线程操作 '${main_slices.data[0].name}' 耗时 ${main_slices.data[0].dur_ms}ms"
+        confidence: high
+        suggestions:
+          - "考虑将耗时操作移到后台线程"
+          - "优化该操作的执行效率"
+
+      # ===== RenderThread 耗时操作 =====
+      - condition: "render_slices?.data?.length > 0 && render_slices.data[0]?.dur_ms > 3"
+        severity: warning
+        diagnosis: "RenderThread 操作 '${render_slices.data[0].name}' 耗时 ${render_slices.data[0].dur_ms}ms"
+        confidence: high
+        suggestions:
+          - "检查是否有复杂的自定义绘制"
+          - "考虑减少绘制复杂度或使用硬件加速"
+
+      # ===== CPU 频率分析 =====
+      - condition: "freq_data?.data?.find(f => f.core_type === 'big')?.avg_freq_mhz < 1500"
+        severity: info
+        diagnosis: "大核频率偏低 (${freq_data.data?.find(f => f.core_type === 'big')?.avg_freq_mhz || 0}MHz)"
+        confidence: medium
+        suggestions:
+          - "系统可能处于省电模式"
+          - "检查温控策略"
+
+      # ===== CPU 频率变化 =====
+      - condition: "freq_timeline?.data?.filter(f => f.change_direction === 'down' && f.core_type === 'big').length > 2"
+        severity: info
+        diagnosis: "大核频率降频 ${freq_timeline.data?.filter(f => f.change_direction === 'down' && f.core_type === 'big').length || 0}次"
+        confidence: medium
+        suggestions:
+          - "可能触发了温控降频"
+          - "检查系统负载和温度"
+
+      # ===== 严重掉帧检测：基于消费端 vsync_missed =====
+      - condition: "${vsync_missed} >= 3"
+        severity: critical
+        diagnosis: "严重卡顿: SF 跳过 ${vsync_missed} 帧 VSync (约 ${vsync_missed} 个 VSync 周期)"
+        confidence: high
+        suggestions:
+          - "检查此时系统是否有大量后台活动"
+          - "查看主线程和 RenderThread 的阻塞原因"
+
+      - condition: "${vsync_missed} >= 1"
+        severity: warning
+        diagnosis: "掉帧: SF 跳过 ${vsync_missed} 帧 VSync"
+        confidence: high
+        suggestions:
+          - "查看上方四象限和耗时操作数据"
+
+output:
+  format: structured