@gracker/smartperfetto 1.0.13

package/skills/composite/startup_detail.skill.yaml

@@ -0,0 +1,1339 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (C) 2024-2026 Gracker (Chris)
+# This file is part of SmartPerfetto. See LICENSE for details.
+
+# =============================================================================
+# 启动事件详细分析（组合 Skill）v2.0
+# =============================================================================
+# 分析单个启动事件的详细信息，包括：
+# - 主线程耗时操作
+# - Binder 调用
+# - 主线程同步 Binder 阻塞
+# - 主线程文件 IO
+# - CPU 大小核占比
+# - 四大象限分析：Running/Runnable/Sleeping 分布
+# - 调度延迟分析
+#
+# 四大象限说明：
+# 1. Running on Big Core - 在大核上运行（性能最优）
+# 2. Running on Little Core - 在小核上运行（可能性能不足）
+# 3. Runnable - 等待 CPU 调度（CPU 资源争抢）
+# 4. Sleeping/Blocked - 睡眠或阻塞（等待 IO/锁/Binder）
+#
+# 大小核判定（自适应）：
+# - 优先按每个 CPU 的最高频率排名划分（更稳健）
+# - 频率样本不足时回退到 capacity
+# - 再不足时才回退到 CPU 编号阈值（低置信度）
+
+name: startup_detail
+version: "2.0"
+type: composite
+category: app_lifecycle
+tier: S
+
+meta:
+  display_name: "启动详情分析"
+  description: "深入分析单个启动过程的性能瓶颈"
+  icon: "search"
+  tags: [startup, detail, composite]
+
+prerequisites:
+  required_tables:
+    - android_startups
+  modules:
+    - android.startup.startups
+    - android.binder
+    - sched
+    - linux.cpu.frequency
+
+inputs:
+  - name: startup_id
+    type: integer
+    required: true
+    description: "启动事件 ID"
+  - name: start_ts
+    type: timestamp
+    required: true
+    description: "启动开始时间戳(ns)"
+  - name: end_ts
+    type: timestamp
+    required: true
+    description: "启动结束时间戳(ns)"
+  - name: dur_ms
+    type: number
+    required: true
+    description: "启动耗时(ms)"
+  - name: package
+    type: string
+    required: true
+    description: "应用包名"
+  - name: startup_type
+    type: string
+    required: true
+    description: "启动类型 (cold/warm/hot)，已经过 bindApplication 存在性校验"
+  - name: original_type
+    type: string
+    required: false
+    description: "Perfetto 原始报告的启动类型（校验前）"
+  - name: ttid_ms
+    type: number
+    required: false
+    description: "TTID (ms)"
+  - name: ttfd_ms
+    type: number
+    required: false
+    description: "TTFD (ms)"
+  # Perfetto 跳转参数
+  - name: perfetto_start
+    type: timestamp
+    required: false
+    description: "Perfetto 跳转开始时间"
+  - name: perfetto_end
+    type: timestamp
+    required: false
+    description: "Perfetto 跳转结束时间"
+
+identity:
+  policy: required
+  scope: process
+  aliases: [package, process_name]
+  rewriteTo: recommended_process_name_param
+
+steps:
+  # ========== 初始化 CPU 拓扑 ==========
+  - id: init_cpu_topology
+    type: skill
+    name: "初始化 CPU 拓扑"
+    skill: cpu_topology_view
+    display:
+      level: hidden
+    optional: true
+
+  # ========== 启动基本信息 ==========
+  - id: startup_info
+    type: atomic
+    name: "启动基本信息"
+    display:
+      level: key
+      layer: deep
+      title: "启动 #${startup_id} 详情"
+      columns:
+        - name: startup_id
+          label: "启动 ID"
+          type: number
+        - name: package
+          label: "包名"
+          type: string
+        - name: startup_type
+          label: "启动类型"
+          type: string
+        - name: type_display
+          label: "类型展示"
+          type: string
+        - name: dur_ms
+          label: "启动耗时(ms)"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: ttid_ms
+          label: "TTID(ms)"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: ttfd_ms
+          label: "TTFD(ms)"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: start_ts
+          label: "开始时间"
+          type: timestamp
+          unit: ns
+          clickAction: navigate_range
+        - name: end_ts
+          label: "结束时间"
+          type: timestamp
+          unit: ns
+          clickAction: navigate_timeline
+        - name: perfetto_start
+          label: "Perfetto开始"
+          type: timestamp
+          unit: ns
+          clickAction: navigate_range
+        - name: perfetto_end
+          label: "Perfetto结束"
+          type: timestamp
+          unit: ns
+          clickAction: navigate_timeline
+        - name: rating
+          label: "评级"
+          type: string
+    sql: |
+      SELECT
+        ${startup_id} as startup_id,
+        '${package}' as package,
+        '${startup_type}' as startup_type,
+        CASE '${startup_type}'
+          WHEN 'cold' THEN '冷启动'
+          WHEN 'warm' THEN '温启动'
+          WHEN 'hot' THEN '热启动'
+          ELSE '${startup_type}'
+        END as type_display,
+        ROUND(${dur_ms}, 2) as dur_ms,
+        ROUND(${ttid_ms}, 2) as ttid_ms,
+        ROUND(${ttfd_ms}, 2) as ttfd_ms,
+        -- 时间戳
+        printf('%d', ${start_ts}) as start_ts,
+        printf('%d', ${end_ts}) as end_ts,
+        -- Perfetto 跳转链接参数
+        printf('%d', COALESCE(${perfetto_start}, ${start_ts})) as perfetto_start,
+        printf('%d', COALESCE(${perfetto_end}, ${end_ts})) as perfetto_end,
+        -- 评级
+        CASE
+          WHEN '${startup_type}' = 'cold' AND ${dur_ms} < 500 THEN '优秀'
+          WHEN '${startup_type}' = 'cold' AND ${dur_ms} < 1000 THEN '良好'
+          WHEN '${startup_type}' = 'cold' AND ${dur_ms} < 2000 THEN '需优化'
+          WHEN '${startup_type}' = 'cold' THEN '严重'
+          WHEN '${startup_type}' = 'warm' AND ${dur_ms} < 200 THEN '优秀'
+          WHEN '${startup_type}' = 'warm' AND ${dur_ms} < 500 THEN '良好'
+          WHEN '${startup_type}' = 'warm' AND ${dur_ms} < 1000 THEN '需优化'
+          WHEN '${startup_type}' = 'warm' THEN '严重'
+          WHEN '${startup_type}' = 'hot' AND ${dur_ms} < 100 THEN '优秀'
+          WHEN '${startup_type}' = 'hot' AND ${dur_ms} < 200 THEN '良好'
+          WHEN '${startup_type}' = 'hot' AND ${dur_ms} < 500 THEN '需优化'
+          WHEN '${startup_type}' = 'hot' THEN '严重'
+          ELSE '需优化'
+        END as rating
+    save_as: startup_basic
+
+  # ========== 大小核占比分析 ==========
+  - id: cpu_core_analysis
+    type: atomic
+    name: "大小核占比分析"
+    display:
+      level: key
+      layer: deep
+      title: "大小核占比"
+      columns:
+        - name: thread_type
+          label: "线程类型"
+          type: string
+        - name: big_core_ms
+          label: "大核运行(ms)"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: little_core_ms
+          label: "小核运行(ms)"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: total_running_ms
+          label: "总运行(ms)"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: big_core_pct
+          label: "大核占比(%)"
+          type: percentage
+          format: percentage
+        - name: little_core_pct
+          label: "小核占比(%)"
+          type: percentage
+          format: percentage
+        - name: used_cpus
+          label: "使用CPU"
+          type: string
+        - name: classify_method
+          label: "核判定来源"
+          type: string
+    sql: |
+      WITH main_thread AS (
+        SELECT t.utid, t.tid, t.name as thread_name, p.pid, p.name as process_name
+        FROM thread t
+        JOIN process p ON t.upid = p.upid
+        WHERE p.name GLOB '${package}*'
+          AND t.tid = p.pid  -- 主线程
+      ),
+      cpu_time AS (
+        SELECT
+          ss.utid,
+          ss.cpu,
+          SUM(
+            MIN(ss.ts + ss.dur, ${end_ts}) - MAX(ss.ts, ${start_ts})
+          ) / 1e6 as dur_ms,
+          COALESCE(ct.core_type, 'unknown') as core_type
+        FROM sched_slice ss
+        JOIN main_thread mt ON ss.utid = mt.utid
+        LEFT JOIN _cpu_topology ct ON ss.cpu = ct.cpu_id
+        WHERE ss.ts < ${end_ts}
+          AND ss.ts + ss.dur > ${start_ts}
+        GROUP BY ss.utid, ss.cpu
+      )
+      SELECT
+        'MainThread' as thread_type,
+        -- medium 核（如 Cortex-A78）性能足够，归入性能核侧
+        ROUND(SUM(CASE WHEN core_type IN ('prime', 'big', 'medium') THEN dur_ms ELSE 0 END), 2) as big_core_ms,
+        ROUND(SUM(CASE WHEN core_type IN ('little') THEN dur_ms ELSE 0 END), 2) as little_core_ms,
+        ROUND(SUM(dur_ms), 2) as total_running_ms,
+        ROUND(100.0 * SUM(CASE WHEN core_type IN ('prime', 'big', 'medium') THEN dur_ms ELSE 0 END) /
+              NULLIF(SUM(dur_ms), 0), 1) as big_core_pct,
+        ROUND(100.0 * SUM(CASE WHEN core_type IN ('little') THEN dur_ms ELSE 0 END) /
+              NULLIF(SUM(dur_ms), 0), 1) as little_core_pct,
+        GROUP_CONCAT(DISTINCT cpu) as used_cpus,
+        'topology_view' as classify_method
+      FROM cpu_time
+      GROUP BY 1
+    save_as: cpu_core
+
+  # ========== CPU 频率分析 ==========
+  - 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: "平均频率(MHz)"
+          type: number
+        - name: max_freq_mhz
+          label: "最高频率(MHz)"
+          type: number
+        - name: min_freq_mhz
+          label: "最低频率(MHz)"
+          type: number
+        - name: classify_method
+          label: "核判定来源"
+          type: string
+    sql: |
+      WITH main_thread AS (
+        SELECT t.utid, t.tid, p.pid
+        FROM thread t
+        JOIN process p ON t.upid = p.upid
+        WHERE p.name GLOB '${package}*'
+          AND t.tid = p.pid
+      ),
+      running_samples AS (
+        SELECT
+          ss.cpu,
+          ss.ts,
+          ss.dur,
+          COALESCE(ct.core_type, 'unknown') as core_type
+        FROM sched_slice ss
+        JOIN main_thread mt ON ss.utid = mt.utid
+        LEFT JOIN _cpu_topology ct ON ss.cpu = ct.cpu_id
+        WHERE ss.ts < ${end_ts}
+          AND ss.ts + ss.dur > ${start_ts}
+      ),
+      freq_samples AS (
+        SELECT
+          cf.cpu,
+          cf.freq as freq_khz,
+          rs.core_type,
+          MIN(cf.ts + cf.dur, ${end_ts}) - MAX(cf.ts, rs.ts) as overlap_dur
+        FROM cpu_frequency_counters cf
+        JOIN running_samples rs ON cf.cpu = rs.cpu
+        WHERE cf.ts < ${end_ts}
+          AND cf.ts + cf.dur > rs.ts
+          AND cf.ts < rs.ts + rs.dur
+      )
+      SELECT
+        core_type,
+        ROUND(SUM(freq_khz * overlap_dur) / NULLIF(SUM(overlap_dur), 0) / 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,
+        'topology_view' as classify_method
+      FROM freq_samples
+      WHERE overlap_dur > 0
+      GROUP BY core_type
+      ORDER BY core_type DESC
+    save_as: cpu_freq
+
+  # ========== CPU 频率爬升分析 ==========
+  - id: freq_rampup
+    type: skill
+    name: "CPU 频率爬升"
+    skill: startup_freq_rampup
+    params:
+      start_ts: "${start_ts}"
+      end_ts: "${end_ts}"
+    display:
+      level: detail
+      layer: deep
+      title: "CPU 频率爬升分析"
+      columns:
+        - name: core_type
+          label: "核类型"
+          type: string
+        - name: early_avg_freq_mhz
+          label: "初期均频(MHz)"
+          type: number
+        - name: steady_avg_freq_mhz
+          label: "稳态均频(MHz)"
+          type: number
+        - name: rampup_pct
+          label: "爬升幅度"
+          type: percentage
+          format: percentage
+        - name: assessment
+          label: "评估"
+          type: string
+    save_as: freq_rampup
+    optional: true
+
+  # ========== 四大象限分析 ==========
+  - id: quadrant_analysis
+    type: atomic
+    name: "四大象限分析"
+    optional: true
+    display:
+      level: key
+      layer: deep
+      title: "四大象限分析"
+      columns:
+        - name: thread_type
+          label: "线程类型"
+          type: string
+        - name: q1_big_running_ms
+          label: "Q1大核运行(ms)"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: q2_little_running_ms
+          label: "Q2小核运行(ms)"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: q3_runnable_ms
+          label: "Q3可运行等待(ms)"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: q4a_io_blocked_ms
+          label: "Q4a IO阻塞(ms)"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: q4b_sleeping_ms
+          label: "Q4b 睡眠等待(ms)"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: total_ms
+          label: "总时长(ms)"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: q1_pct
+          label: "Q1占比(%)"
+          type: percentage
+          format: percentage
+        - name: q2_pct
+          label: "Q2占比(%)"
+          type: percentage
+          format: percentage
+        - name: q3_pct
+          label: "Q3占比(%)"
+          type: percentage
+          format: percentage
+        - name: q4a_pct
+          label: "Q4a占比(%)"
+          type: percentage
+          format: percentage
+        - name: q4b_pct
+          label: "Q4b占比(%)"
+          type: percentage
+          format: percentage
+        - name: classify_method
+          label: "核判定来源"
+          type: string
+    sql: |
+      WITH main_thread AS (
+        SELECT t.utid, t.tid, t.name as thread_name, p.pid, p.name as process_name
+        FROM thread t
+        JOIN process p ON t.upid = p.upid
+        WHERE p.name GLOB '${package}*'
+          AND t.tid = p.pid
+      ),
+      thread_states AS (
+        SELECT
+          ts.utid,
+          ts.state,
+          ts.cpu,
+          COALESCE(ct.core_type, 'unknown') as core_type,
+          SUM(
+            MIN(ts.ts + ts.dur, ${end_ts}) - MAX(ts.ts, ${start_ts})
+          ) / 1e6 as dur_ms
+        FROM thread_state ts
+        JOIN main_thread mt ON ts.utid = mt.utid
+        LEFT JOIN _cpu_topology ct ON ts.cpu = ct.cpu_id
+        WHERE ts.ts < ${end_ts}
+          AND ts.ts + ts.dur > ${start_ts}
+        GROUP BY ts.utid, ts.state, ts.cpu
+      ),
+      quadrant_data AS (
+        SELECT
+          CASE
+            WHEN state = 'Running' AND core_type IN ('prime', 'big', 'medium') THEN 'Q1_big_running'
+            WHEN state = 'Running' AND core_type IN ('little') THEN 'Q2_little_running'
+            WHEN state IN ('R', 'R+') THEN 'Q3_runnable'
+            WHEN state IN ('D', 'DK') THEN 'Q4a_io_blocked'
+            WHEN state IN ('S', 'I') THEN 'Q4b_sleeping'
+            ELSE 'other'
+          END as quadrant,
+          dur_ms
+        FROM thread_states
+      )
+      SELECT
+        'MainThread' as thread_type,
+        ROUND(SUM(CASE WHEN quadrant = 'Q1_big_running' THEN dur_ms ELSE 0 END), 2) as q1_big_running_ms,
+        ROUND(SUM(CASE WHEN quadrant = 'Q2_little_running' THEN dur_ms ELSE 0 END), 2) as q2_little_running_ms,
+        ROUND(SUM(CASE WHEN quadrant = 'Q3_runnable' THEN dur_ms ELSE 0 END), 2) as q3_runnable_ms,
+        ROUND(SUM(CASE WHEN quadrant = 'Q4a_io_blocked' THEN dur_ms ELSE 0 END), 2) as q4a_io_blocked_ms,
+        ROUND(SUM(CASE WHEN quadrant = 'Q4b_sleeping' THEN dur_ms ELSE 0 END), 2) as q4b_sleeping_ms,
+        ROUND(SUM(dur_ms), 2) as total_ms,
+        -- 百分比
+        ROUND(100.0 * SUM(CASE WHEN quadrant = 'Q1_big_running' THEN dur_ms ELSE 0 END) /
+              NULLIF(SUM(dur_ms), 0), 1) as q1_pct,
+        ROUND(100.0 * SUM(CASE WHEN quadrant = 'Q2_little_running' THEN dur_ms ELSE 0 END) /
+              NULLIF(SUM(dur_ms), 0), 1) as q2_pct,
+        ROUND(100.0 * SUM(CASE WHEN quadrant = 'Q3_runnable' THEN dur_ms ELSE 0 END) /
+              NULLIF(SUM(dur_ms), 0), 1) as q3_pct,
+        ROUND(100.0 * SUM(CASE WHEN quadrant = 'Q4a_io_blocked' THEN dur_ms ELSE 0 END) /
+              NULLIF(SUM(dur_ms), 0), 1) as q4a_pct,
+        ROUND(100.0 * SUM(CASE WHEN quadrant = 'Q4b_sleeping' THEN dur_ms ELSE 0 END) /
+              NULLIF(SUM(dur_ms), 0), 1) as q4b_pct,
+        'topology_view' as classify_method
+      FROM quadrant_data
+      GROUP BY 1
+    save_as: quadrant
+
+  # ========== 主线程摆核时序（按时间桶分析核类型变化） ==========
+  - id: cpu_placement_timeline
+    type: skill
+    name: "摆核时序分析"
+    skill: startup_cpu_placement_timeline
+    params:
+      package: "${package}"
+      start_ts: "${start_ts}"
+      end_ts: "${end_ts}"
+      bucket_ms: 50
+    display:
+      level: detail
+      layer: deep
+      title: "主线程摆核时序（50ms 桶）"
+      columns:
+        - name: bucket_offset_ms
+          label: "偏移(ms)"
+          type: number
+        - name: big_core_ms
+          label: "大核(ms)"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: little_core_ms
+          label: "小核(ms)"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: big_core_pct
+          label: "大核占比"
+          type: percentage
+          format: percentage
+        - name: used_cpus
+          label: "CPU"
+          type: string
+    save_as: cpu_placement
+    optional: true
+
+  # ========== 主线程关键 Slice ==========
+  - id: main_thread_slices
+    type: skill
+    name: "主线程耗时操作"
+    skill: main_thread_slices_in_range
+    params:
+      start_ts: "${start_ts}"
+      end_ts: "${end_ts}"
+      package: "${package}"
+      min_dur_ns: 1000000
+      top_k: 10
+    display:
+      level: key
+      layer: deep
+      show: false
+      title: "主线程耗时操作 Top10"
+      columns:
+        - name: slice_name
+          label: "切片名"
+          type: string
+        - name: count
+          label: "次数"
+          type: number
+          format: compact
+        - name: total_ms
+          label: "总耗时"
+          type: duration
+          format: duration_ms
+        - name: avg_ms
+          label: "平均耗时"
+          type: duration
+          format: duration_ms
+        - name: max_ms
+          label: "最大耗时"
+          type: duration
+          format: duration_ms
+        - name: percent
+          label: "区间占比"
+          type: percentage
+          format: percentage
+    save_as: main_slices
+
+  # ========== 主线程可操作热点（剔除框架包裹切片，含 exclusive time） ==========
+  - id: actionable_main_thread_slices
+    type: atomic
+    name: "主线程可操作热点"
+    display:
+      level: detail
+      layer: deep
+      title: "主线程可操作热点 Top5"
+      columns:
+        - name: slice_name
+          label: "切片名"
+          type: string
+        - name: count
+          label: "次数"
+          type: number
+          format: compact
+        - name: total_ms
+          label: "总耗时(wall)"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: self_ms
+          label: "自身耗时"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: avg_ms
+          label: "平均耗时"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: max_ms
+          label: "最大耗时"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: percent
+          label: "区间占比(wall)"
+          type: percentage
+          format: percentage
+        - name: self_percent
+          label: "区间占比(self)"
+          type: percentage
+          format: percentage
+        - name: is_framework_wrapper
+          label: "框架包裹切片"
+          type: boolean
+    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
+      ),
+      slice_with_self AS (
+        SELECT
+          s.id,
+          s.name as slice_name,
+          MIN(s.ts + s.dur, ${end_ts}) - MAX(s.ts, ${start_ts}) as clipped_dur,
+          (MIN(s.ts + s.dur, ${end_ts}) - MAX(s.ts, ${start_ts}))
+            - COALESCE((
+                SELECT SUM(
+                  MIN(c.ts + c.dur, MIN(s.ts + s.dur, ${end_ts}))
+                  - MAX(c.ts, MAX(s.ts, ${start_ts}))
+                )
+                FROM slice c
+                WHERE c.parent_id = s.id
+                  AND c.ts < ${end_ts}
+                  AND c.ts + c.dur > ${start_ts}
+              ), 0) as self_dur
+        FROM slice s
+        JOIN thread_track tt ON s.track_id = tt.id
+        JOIN main_thread mt ON tt.utid = mt.utid
+        WHERE s.ts < ${end_ts}
+          AND s.ts + s.dur > ${start_ts}
+      ),
+      agg AS (
+        SELECT
+          slice_name,
+          COUNT(*) as count,
+          ROUND(SUM(clipped_dur) / 1e6, 2) as total_ms,
+          ROUND(SUM(self_dur) / 1e6, 2) as self_ms,
+          ROUND(AVG(clipped_dur) / 1e6, 2) as avg_ms,
+          ROUND(MAX(clipped_dur) / 1e6, 2) as max_ms,
+          ROUND(100.0 * SUM(clipped_dur) / NULLIF(${end_ts} - ${start_ts}, 0), 1) as percent,
+          ROUND(100.0 * SUM(self_dur) / NULLIF(${end_ts} - ${start_ts}, 0), 1) as self_percent,
+          CASE
+            WHEN lower(slice_name) IN ('clienttransactionexecuted', 'activitystart', 'bindapplication') THEN 1
+            WHEN lower(slice_name) GLOB 'performcreate:*' THEN 1
+            WHEN lower(slice_name) GLOB 'performresume*' THEN 1
+            WHEN lower(slice_name) GLOB 'activitythreadmain*' THEN 1
+            ELSE 0
+          END as is_framework_wrapper
+        FROM slice_with_self
+        WHERE clipped_dur >= 1000000
+        GROUP BY slice_name
+      )
+      SELECT
+        slice_name,
+        count,
+        total_ms,
+        self_ms,
+        avg_ms,
+        max_ms,
+        percent,
+        self_percent,
+        is_framework_wrapper
+      FROM agg
+      ORDER BY is_framework_wrapper ASC, self_ms DESC
+      LIMIT 5
+    save_as: actionable_main_slices
+
+  # ========== 主线程文件 IO 分析 ==========
+  - id: main_thread_file_io
+    type: skill
+    name: "主线程文件 IO"
+    skill: main_thread_file_io_in_range
+    params:
+      start_ts: "${start_ts}"
+      end_ts: "${end_ts}"
+      package: "${package}"
+      min_dur_ns: 500000
+      top_k: 10
+    display:
+      level: key
+      layer: deep
+      show: false
+      title: "主线程文件 IO Top10"
+      columns:
+        - name: io_slice
+          label: "IO 切片"
+          type: string
+        - name: count
+          label: "次数"
+          type: number
+          format: compact
+        - name: total_ms
+          label: "总耗时"
+          type: duration
+          format: duration_ms
+        - name: avg_ms
+          label: "平均耗时"
+          type: duration
+          format: duration_ms
+        - name: max_ms
+          label: "最大耗时"
+          type: duration
+          format: duration_ms
+        - name: percent
+          label: "区间占比"
+          type: percentage
+          format: percentage
+    save_as: main_file_io
+
+  # ========== Binder 调用分析 ==========
+  - id: binder_analysis
+    type: skill
+    name: "Binder 调用分析"
+    skill: binder_in_range
+    params:
+      start_ts: "${start_ts}"
+      end_ts: "${end_ts}"
+      package: "${package}"
+    display:
+      level: key
+      layer: deep
+      show: false
+      title: "Binder 调用"
+      columns:
+        - name: client_process
+          label: "客户端"
+          type: string
+        - name: server_process
+          label: "服务端"
+          type: string
+        - name: call_count
+          label: "调用次数"
+          type: number
+          format: compact
+        - name: total_client_ms
+          label: "总耗时"
+          type: duration
+          format: duration_ms
+        - name: max_delay_ms
+          label: "最大延迟"
+          type: duration
+          format: duration_ms
+        - name: avg_delay_ms
+          label: "平均延迟"
+          type: duration
+          format: duration_ms
+        - name: slow_calls
+          label: "慢调用"
+          type: number
+    save_as: binder_calls
+
+  # ========== 主线程同步 Binder ==========
+  - id: main_thread_sync_binder
+    type: skill
+    name: "主线程同步 Binder"
+    skill: binder_blocking_in_range
+    params:
+      start_ts: "${start_ts}"
+      end_ts: "${end_ts}"
+      package: "${package}"
+    display:
+      level: key
+      layer: deep
+      show: false
+      title: "主线程同步 Binder Top10"
+      columns:
+        - name: server_process
+          label: "对端进程"
+          type: string
+        - name: interface
+          label: "接口"
+          type: string
+        - name: call_count
+          label: "调用次数"
+          type: number
+        - name: total_block_ms
+          label: "总阻塞时间"
+          type: duration
+          format: duration_ms
+        - name: server_exec_ms
+          label: "服务端执行"
+          type: duration
+          format: duration_ms
+        - name: max_block_ms
+          label: "最大阻塞"
+          type: duration
+          format: duration_ms
+        - name: is_main_blocked
+          label: "主线程被阻"
+          type: boolean
+    save_as: main_sync_binder
+
+  # ========== Binder 线程池分析 ==========
+  - id: binder_pool
+    type: skill
+    name: "Binder 线程池分析"
+    skill: startup_binder_pool_analysis
+    params:
+      package: "${package}"
+      start_ts: "${start_ts}"
+      end_ts: "${end_ts}"
+    display:
+      level: detail
+      layer: deep
+      title: "Binder 线程池分析"
+      columns:
+        - name: metric
+          label: "指标"
+          type: string
+        - name: value
+          label: "值"
+          type: string
+        - name: assessment
+          label: "评估"
+          type: string
+    save_as: binder_pool
+    optional: true
+
+  # ========== 调度延迟分析 ==========
+  - id: sched_latency
+    type: skill
+    name: "调度延迟分析"
+    skill: main_thread_sched_latency_in_range
+    params:
+      start_ts: "${start_ts}"
+      end_ts: "${end_ts}"
+      package: "${package}"
+    display:
+      level: detail
+      layer: deep
+      show: false
+      title: "主线程调度延迟"
+      columns:
+        - name: thread_name
+          label: "线程"
+          type: string
+        - name: runnable_count
+          label: "等待次数"
+          type: number
+        - name: total_runnable_ms
+          label: "总等待"
+          type: duration
+          format: duration_ms
+        - name: max_latency_ms
+          label: "最大延迟"
+          type: duration
+          format: duration_ms
+        - name: avg_latency_ms
+          label: "平均延迟"
+          type: duration
+          format: duration_ms
+        - name: long_wait_count
+          label: ">2ms 次数"
+          type: number
+        - name: severe_count
+          label: ">8ms 次数"
+          type: number
+    save_as: sched_delay
+
+  # ========== 主线程状态分布（含 blocked_functions） ==========
+  - id: main_thread_state
+    type: skill
+    name: "主线程状态分布"
+    skill: startup_main_thread_states_in_range
+    params:
+      start_ts: "${start_ts}"
+      end_ts: "${end_ts}"
+      package: "${package}"
+      startup_id: "${startup_id}"
+      startup_type: "${startup_type}"
+    display:
+      level: key
+      layer: deep
+      show: false
+      title: "主线程状态分布"
+      columns:
+        - name: state
+          label: "状态"
+          type: string
+        - name: state_desc
+          label: "状态说明"
+          type: string
+        - name: total_dur_ms
+          label: "总耗时"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: percent
+          label: "占比"
+          type: percentage
+          format: percentage
+        - name: count
+          label: "次数"
+          type: number
+          format: compact
+        - name: blocked_functions
+          label: "阻塞函数"
+          type: string
+          format: truncate
+    save_as: thread_states
+
+  # ========== 关键任务发现（全线程四象限 + 摆核） ==========
+  - id: critical_tasks
+    type: skill
+    name: "启动关键任务"
+    skill: startup_critical_tasks
+    params:
+      package: "${package}"
+      start_ts: "${start_ts}"
+      end_ts: "${end_ts}"
+      top_k: 15
+    display:
+      level: key
+      layer: deep
+      title: "启动关键任务（全线程四象限）"
+      columns:
+        - name: thread_name
+          label: "线程"
+          type: string
+        - name: role
+          label: "角色"
+          type: string
+        - name: total_cpu_ms
+          label: "CPU 时间"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: q1_big_running_ms
+          label: "Q1 大核运行"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: q2_little_running_ms
+          label: "Q2 小核运行"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: q3_runnable_ms
+          label: "Q3 等待调度"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: q4b_sleeping_ms
+          label: "Q4b 睡眠等待"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: running_pct
+          label: "运行占比"
+          type: percentage
+          format: percentage
+        - name: big_core_pct
+          label: "大核占比"
+          type: percentage
+          format: percentage
+        - name: migrations
+          label: "核迁移"
+          type: number
+        - name: cross_cluster_migrations
+          label: "跨 cluster"
+          type: number
+    save_as: critical_tasks
+    optional: true
+
+  # ========== 线程阻塞关系图 ==========
+  - id: thread_blocking_graph
+    type: skill
+    name: "线程阻塞关系"
+    skill: startup_thread_blocking_graph
+    params:
+      package: "${package}"
+      start_ts: "${start_ts}"
+      end_ts: "${end_ts}"
+      min_block_ms: 1
+      top_k: 20
+    display:
+      level: detail
+      layer: deep
+      title: "线程阻塞关系图"
+      columns:
+        - name: blocked_thread
+          label: "被阻塞线程"
+          type: string
+        - name: blocked_state
+          label: "阻塞状态"
+          type: string
+        - name: blocked_function
+          label: "阻塞函数"
+          type: string
+          format: code
+        - name: waker_thread
+          label: "唤醒者"
+          type: string
+        - name: waker_process
+          label: "唤醒者进程"
+          type: string
+        - name: waker_current_slice
+          label: "唤醒者操作"
+          type: string
+        - name: total_block_ms
+          label: "总阻塞"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: block_count
+          label: "次数"
+          type: number
+    save_as: blocking_graph
+    optional: true
+
+  # ========== JIT 影响分析 ==========
+  - id: jit_analysis
+    type: skill
+    name: "JIT 影响分析"
+    skill: startup_jit_analysis
+    params:
+      package: "${package}"
+      start_ts: "${start_ts}"
+      end_ts: "${end_ts}"
+    display:
+      level: detail
+      layer: deep
+      title: "JIT 影响分析"
+      columns:
+        - name: metric
+          label: "指标"
+          type: string
+        - name: value
+          label: "值"
+          type: string
+        - name: assessment
+          label: "评估"
+          type: string
+    save_as: jit_analysis
+    optional: true
+    condition: "'${startup_type}' = 'cold'"
+
+  # ========== 热点 Slice 线程状态分布（per-slice 根因定位） ==========
+  - id: hot_slice_states
+    type: skill
+    name: "热点 Slice 线程状态"
+    skill: startup_hot_slice_states
+    params:
+      package: "${package}"
+      start_ts: "${start_ts}"
+      end_ts: "${end_ts}"
+      top_n: 10
+    display:
+      level: detail
+      layer: deep
+      title: "热点 Slice 线程状态分布"
+      columns:
+        - name: slice_name
+          label: "切片名"
+          type: string
+        - name: slice_dur_ms
+          label: "切片耗时"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: slice_ts
+          label: "开始时间"
+          type: timestamp
+        - name: state
+          label: "线程状态"
+          type: string
+        - name: state_dur_ms
+          label: "状态耗时"
+          type: duration
+          format: duration_ms
+          unit: ms
+        - name: state_pct
+          label: "状态占比"
+          type: percentage
+          format: percentage
+        - name: blocked_functions
+          label: "阻塞函数"
+          type: string
+          format: truncate
+    save_as: hot_slice_states
+    optional: true
+
+  # ========== 启动诊断 ==========
+  - id: startup_diagnosis
+    type: diagnostic
+    name: "启动诊断"
+    display:
+      level: key
+      layer: deep
+      title: "问题诊断"
+    inputs: [startup_basic, cpu_core, cpu_freq, freq_rampup, quadrant, cpu_placement, main_slices, actionable_main_slices, main_file_io, binder_calls, main_sync_binder, binder_pool, sched_delay, thread_states, critical_tasks, blocking_graph, jit_analysis, hot_slice_states]
+    rules:
+      # 大核占比偏低 + Runnable 明显（仅在判定来源可信时触发）
+      - condition: "cpu_core.data[0]?.big_core_pct < 20 && quadrant.data[0]?.q3_runnable_ms > 50 && !(cpu_core.data[0]?.classify_method || '').includes('cpu_id_fallback')"
+        severity: warning
+        diagnosis: "主线程大核占比偏低（${cpu_core.data[0].big_core_pct}%）且 Runnable 排队明显（${quadrant.data[0].q3_runnable_ms}ms），可能存在调度供给不足"
+        confidence: medium
+        suggestions:
+          - "检查是否有其他高优先级进程抢占大核"
+          - "考虑调整进程优先级或使用 setThreadPriority"
+
+      # 核判定来源不可靠时，避免把大小核结论当根因
+      - condition: "(cpu_core.data[0]?.classify_method || '').includes('cpu_id_fallback')"
+        severity: info
+        diagnosis: "核类型判定回退到 CPU 编号阈值，大小核相关结论置信度有限"
+        confidence: medium
+        suggestions:
+          - "补充或检查 cpu_frequency/cpu capacity 数据后再判断大小核调度问题"
+
+      # Runnable 等待过长（需由调度延迟指标佐证）
+      - condition: "quadrant.data[0]?.q3_runnable_ms > 50 && (sched_delay.data[0]?.severe_count || 0) > 3"
+        severity: warning
+        diagnosis: "主线程 Runnable 等待 ${quadrant.data[0].q3_runnable_ms}ms，且存在 ${sched_delay.data[0].severe_count} 次 >8ms 调度延迟"
+        confidence: high
+        suggestions:
+          - "CPU 资源争抢严重，检查后台线程负载"
+          - "减少启动期间的并发线程数"
+
+      # Q4a IO 阻塞占比过高（D/DK 状态 = 磁盘/IO 等待）
+      - condition: "quadrant.data[0]?.q4a_pct > 15 && ((main_file_io.data[0]?.percent || 0) > 2 || (thread_states?.data?.find(r => r.state === 'D')?.percent || 0) > 5)"
+        severity: warning
+        diagnosis: "主线程 IO 阻塞(D 状态) 占比 ${quadrant.data[0].q4a_pct}%，存在磁盘/IO 等待瓶颈"
+        confidence: high
+        suggestions:
+          - "将数据库/文件读写操作移至后台线程"
+          - "使用异步 IO 或延迟加载策略"
+          - "检查 APK/DEX 文件读取是否在关键路径"
+
+      # Q4b 睡眠等待占比过高（S/I 状态 = 锁/Binder/futex 等待）
+      - condition: "quadrant.data[0]?.q4b_pct > 30 && ((main_sync_binder?.data?.find(r => r.is_main_blocked === 1)?.total_block_ms) || 0) > 20"
+        severity: warning
+        diagnosis: "主线程睡眠等待(S 状态) 占比 ${quadrant.data[0].q4b_pct}% 且存在 Binder 阻塞证据"
+        confidence: medium
+        suggestions:
+          - "检查主线程同步 Binder 调用，改为异步"
+          - "减少启动期间的锁竞争"
+
+      # 主线程文件 IO 偏高（需与 IO 阻塞相互印证）
+      - condition: "(main_file_io.data[0]?.total_ms > 50 || main_file_io.data[0]?.percent > 5) && ((quadrant.data[0]?.q4a_pct || 0) > 10 || (quadrant.data[0]?.q4b_pct || 0) > 20)"
+        severity: warning
+        diagnosis: "主线程文件 IO '${main_file_io.data[0].io_slice}' 耗时 ${main_file_io.data[0].total_ms}ms（占比 ${main_file_io.data[0].percent}%）"
+        confidence: high
+        suggestions:
+          - "避免在首帧前执行文件读取/写入，改为预取或延迟加载"
+          - "数据库初始化改为异步，合并小 IO 为批量 IO"
+
+      # 主线程同步 Binder 偏高（仅当确认主线程被阻塞）
+      - condition: "(((main_sync_binder?.data?.find(r => r.is_main_blocked === 1)?.total_block_ms) || 0) > 80 || ((main_sync_binder?.data?.find(r => r.is_main_blocked === 1)?.max_block_ms) || 0) > 16) && ((quadrant.data[0]?.q4b_pct || 0) > 15 || (quadrant.data[0]?.q3_runnable_ms || 0) > 20)"
+        severity: warning
+        diagnosis: "主线程同步 Binder '${main_sync_binder.data.find(r => r.is_main_blocked === 1)?.interface}' 阻塞 ${main_sync_binder.data.find(r => r.is_main_blocked === 1)?.total_block_ms}ms"
+        confidence: high
+        suggestions:
+          - "将同步 Binder 改为异步或迁移到后台线程"
+          - "减少启动首屏前的跨进程依赖调用"
+
+      # Binder 调用耗时过长（仅当主线程同步 Binder 也偏高）
+      - condition: "binder_calls.data[0]?.total_client_ms > 100 && ((main_sync_binder?.data?.find(r => r.is_main_blocked === 1)?.total_block_ms) || 0) > 20"
+        severity: warning
+        diagnosis: "Binder 调用 ${binder_calls.data[0].server_process} 总耗时 ${binder_calls.data[0].total_client_ms}ms，且主线程存在同步 Binder 阻塞"
+        confidence: high
+        suggestions:
+          - "减少启动期间的 IPC 调用"
+          - "使用异步 Binder 或延迟调用"
+
+      # 严重调度延迟
+      - condition: "(sched_delay.data[0]?.severe_count || 0) > 5 && (sched_delay.data[0]?.max_latency_ms || 0) > 8"
+        severity: warning
+        diagnosis: "存在 ${sched_delay.data[0].severe_count} 次严重调度延迟 (>8ms)，最大延迟 ${sched_delay.data[0].max_latency_ms}ms"
+        confidence: medium
+        suggestions:
+          - "检查系统负载，减少后台进程"
+          - "考虑使用 SCHED_FIFO 策略"
+
+      # 可操作业务 Slice 耗时过长（优先使用非框架包裹切片）
+      - condition: "((actionable_main_slices.data[0]?.is_framework_wrapper || 0) === 0) && (actionable_main_slices.data[0]?.max_ms || 0) > 80 && (actionable_main_slices.data[0]?.percent || 0) > 15"
+        severity: warning
+        diagnosis: "主线程可操作热点 '${actionable_main_slices.data[0].slice_name}' 最长耗时 ${actionable_main_slices.data[0].max_ms}ms（占比 ${actionable_main_slices.data[0].percent}%）"
+        confidence: high
+        suggestions:
+          - "优先下钻该切片内部子阶段，定位可迁移到后台的初始化任务"
+          - "将首帧前非关键任务延后到 TTID 之后执行"
+
+      # 单个 Slice 耗时过长（且区间占比高）
+      - condition: "main_slices.data[0]?.max_ms > 100 && (main_slices.data[0]?.percent || 0) > 20 && !['clientTransactionExecuted', 'activityStart', 'bindApplication'].includes(main_slices.data[0]?.slice_name || '') && !(main_slices.data[0]?.slice_name || '').startsWith('performCreate:')"
+        severity: warning
+        diagnosis: "主线程操作 '${main_slices.data[0].slice_name}' 最长耗时 ${main_slices.data[0].max_ms}ms"
+        confidence: high
+        suggestions:
+          - "优化该操作或移到后台线程"
+          - "检查是否可以分批执行"
+
+      # Q4b 占比高 + 线程状态 S 占比高 + blocked_functions 含锁等待
+      - condition: "(quadrant.data[0]?.q4b_pct || 0) > 25 && thread_states?.data?.find(r => r.state === 'S')?.percent > 20 && (thread_states?.data?.find(r => r.state === 'S')?.blocked_functions || '').includes('futex')"
+        severity: warning
+        diagnosis: "主线程 S(Sleeping) 状态占比 ${thread_states.data.find(r => r.state === 'S').percent}%，blocked_functions 含 futex 相关函数，存在锁竞争"
+        confidence: high
+        suggestions:
+          - "检查主线程是否存在锁竞争（synchronized/ReentrantLock）"
+          - "减少启动期间的线程同步操作"
+
+      # Q4a 占比高 + D 状态（IO 阻塞）明显
+      - condition: "(quadrant.data[0]?.q4a_pct || 0) > 10 && thread_states?.data?.find(r => r.state === 'D')?.percent > 5"
+        severity: warning
+        diagnosis: "主线程 D(Disk Sleep) 状态占比 ${thread_states.data.find(r => r.state === 'D').percent}%（${thread_states.data.find(r => r.state === 'D').total_dur_ms}ms），存在 IO 阻塞"
+        confidence: high
+        suggestions:
+          - "将数据库/文件操作移至后台线程"
+          - "使用异步 IO 或延迟加载"
+
+      # === Critical Task 诊断规则 ===
+
+      # JIT 线程与主线程争抢大核
+      - condition: "(critical_tasks?.data?.find(t => t.role === 'jit')?.total_cpu_ms || 0) > 20 && (critical_tasks?.data?.find(t => t.role === 'jit')?.big_core_pct || 0) > 50"
+        severity: warning
+        diagnosis: "JIT 线程 CPU 时间 ${critical_tasks.data.find(t => t.role === 'jit').total_cpu_ms}ms（大核占比 ${critical_tasks.data.find(t => t.role === 'jit').big_core_pct}%），可能与主线程争抢大核"
+        confidence: medium
+        suggestions:
+          - "使用 Baseline Profile 减少冷启动 JIT 编译需求"
+          - "检查是否缺少 .prof 或 .dm 文件"
+
+      # RenderThread 被调度到小核
+      - condition: "(critical_tasks?.data?.find(t => t.role === 'render')?.total_cpu_ms || 0) > 5 && (critical_tasks?.data?.find(t => t.role === 'render')?.big_core_pct || 0) < 30"
+        severity: info
+        diagnosis: "RenderThread 大核占比仅 ${critical_tasks.data.find(t => t.role === 'render').big_core_pct}%，首帧渲染可能因小核性能不足而变慢"
+        confidence: medium
+        suggestions:
+          - "检查 RenderThread 是否被调度到小核运行"
+          - "大量 GPU 指令在小核上提交会增加 TTID"
+
+      # 主线程核迁移频繁
+      - condition: "(critical_tasks?.data?.find(t => t.role === 'main')?.cross_cluster_migrations || 0) > 10"
+        severity: warning
+        diagnosis: "主线程跨 cluster 核迁移 ${critical_tasks.data.find(t => t.role === 'main').cross_cluster_migrations} 次，L2 Cache 反复失效导致性能损失"
+        confidence: high
+        suggestions:
+          - "频繁跨 cluster 迁移说明调度器未稳定分配核心"
+          - "检查是否有其他线程/进程在启动期间与主线程争抢 CPU"
+
+      # 多线程总 CPU 时间远超启动墙钟时间（CPU 争抢激烈）
+      - condition: "critical_tasks?.data?.length > 0 && critical_tasks.data.reduce((sum, t) => sum + (t.total_cpu_ms || 0), 0) > ${dur_ms} * 2"
+        severity: info
+        diagnosis: "所有线程总 CPU 时间 ${Math.round(critical_tasks.data.reduce((sum, t) => sum + (t.total_cpu_ms || 0), 0))}ms 是启动墙钟时间 ${dur_ms}ms 的 ${(critical_tasks.data.reduce((sum, t) => sum + (t.total_cpu_ms || 0), 0) / ${dur_ms}).toFixed(1)} 倍，CPU 争抢激烈"
+        confidence: medium
+        suggestions:
+          - "减少启动期间的后台线程并发"
+          - "延迟非关键初始化到首帧之后"
+
+      # 主线程被 system_server 阻塞（从 blocking_graph 中检测跨进程阻塞）
+      - condition: "(blocking_graph?.data?.find(b => b.blocked_role === 'main' && b.waker_process === 'system_server')?.total_block_ms || 0) > 30"
+        severity: warning
+        diagnosis: "主线程被 system_server 阻塞 ${blocking_graph.data.find(b => b.blocked_role === 'main' && b.waker_process === 'system_server').total_block_ms}ms（函数：${blocking_graph.data.find(b => b.blocked_role === 'main' && b.waker_process === 'system_server').blocked_function}）"
+        confidence: high
+        suggestions:
+          - "system_server 处理延迟可能因系统负载高"
+          - "检查启动期间是否有密集的跨进程 Binder 调用"
+
+      # 主线程被 GC 线程阻塞
+      - condition: "(blocking_graph?.data?.find(b => b.blocked_role === 'main' && b.waker_thread === 'HeapTaskDaemon')?.total_block_ms || 0) > 10"
+        severity: warning
+        diagnosis: "主线程被 GC 阻塞 ${blocking_graph.data.find(b => b.blocked_role === 'main' && b.waker_thread === 'HeapTaskDaemon').total_block_ms}ms"
+        confidence: high
+        suggestions:
+          - "减少启动期间的对象分配"
+          - "避免在 Application.onCreate() 中创建大量临时对象"
+
+      # === Phase C 精细化诊断规则 ===
+
+      # 启动初期大核频率显著偏低（升频延迟）
+      - condition: "freq_rampup?.data?.find(r => r.core_type === 'big' || r.core_type === 'prime')?.rampup_pct > 50"
+        severity: info
+        diagnosis: "启动初期大核频率比稳态低 ${freq_rampup.data.find(r => r.core_type === 'big' || r.core_type === 'prime').rampup_pct}%，存在升频延迟"
+        confidence: medium
+        suggestions:
+          - "冷启动初期 CPU 可能从低频 idle 唤醒，Governor 需要几个调度周期才升频"
+          - "Qualcomm WALT 和 Pixel schedutil 的升频速度不同，可查看厂商特定优化"
+
+      # 启动初期主线程被困小核（摆核时序检测）
+      - condition: "cpu_placement?.data?.length > 2 && (cpu_placement.data[0]?.big_core_pct || 0) < 20 && (cpu_placement.data[2]?.big_core_pct || 0) > 60"
+        severity: warning
+        diagnosis: "启动前 100ms 主线程大核占比仅 ${cpu_placement.data[0].big_core_pct}%，之后升至 ${cpu_placement.data[2].big_core_pct}%。启动初期被困在小核"
+        confidence: medium
+        suggestions:
+          - "可能因 Zygote fork 继承了小核亲和性，或 top-app cgroup 设置有延迟"
+          - "bindApplication 阶段的性能受此影响最大"
+
+      # Binder 线程池利用率过高
+      - condition: "binder_pool?.data?.find(r => r.metric === '线程池利用率')?.value?.includes('⚠️')"
+        severity: warning
+        diagnosis: "Binder 线程池利用率过高，新的 Binder 回复可能排队等待"
+        confidence: medium
+        suggestions:
+          - "减少启动期间并行的 Binder 调用"
+          - "将非关键 IPC 延迟到首帧之后"
+
+output:
+  display:
+    level: key
+    format: summary