@gracker/smartperfetto 1.0.15 → 1.0.17

package/skills/atomic/process_slice_cpu_hotspots.skill.yaml

@@ -0,0 +1,321 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (C) 2024-2026 Gracker (Chris)
+# This file is part of SmartPerfetto. See LICENSE for details.
+
+# =============================================================================
+# 进程 Slice CPU 热点（原子 Skill）
+# =============================================================================
+# 按进程统计 named slice 的实际 Running CPU time。不同于 wall duration，
+# 这里把 slice 时间段和 thread_state=Running 区间求交，避免把睡眠、IO 等
+# 非执行时间误算成 CPU 消耗。
+
+name: process_slice_cpu_hotspots
+version: "1.0"
+type: atomic
+category: cpu
+tier: B
+
+meta:
+  display_name: "进程 Slice CPU 热点"
+  description: "按进程聚合 named slice 的实际 Running CPU 时间"
+  icon: "query_stats"
+  tags: [cpu, slice, thread_state, running, hotspot, atomic]
+
+triggers:
+  keywords:
+    zh: [slice CPU, 函数 CPU, 热点 slice, CPU 热点, Running 时间, named slice]
+    en: [slice cpu, function cpu, hot slices, cpu hotspots, running time, named slice]
+  patterns:
+    - ".*(slice|函数|方法).*(CPU|cpu|消耗|热点).*"
+    - ".*(CPU|cpu).*(slice|function|method|named).*"
+
+prerequisites:
+  modules:
+    - sched
+  required_tables:
+    - slice
+    - thread_track
+    - thread
+    - process
+    - thread_state
+
+identity:
+  policy: verify_if_present
+  scope: process
+  aliases: [package, process_name]
+  rewriteTo: recommended_process_name_param
+
+inputs:
+  - name: package
+    type: string
+    required: false
+    description: "目标应用包名或进程名前缀"
+  - name: process_name
+    type: string
+    required: false
+    description: "目标进程名；当 package 为空时使用"
+  - name: upid
+    type: integer
+    required: false
+    description: "可选 trace 内进程 ID；优先级高于 package/process_name"
+  - name: slice_name
+    type: string
+    required: false
+    description: "可选 slice 名称过滤；默认字面包含匹配，包含 % 时按 SQL LIKE 模式匹配"
+  - name: thread_scope
+    type: string
+    required: false
+    default: all
+    description: "线程范围：all/main/render/main_render"
+  - name: start_ts
+    type: timestamp
+    required: false
+    description: "分析起始时间戳(ns)，默认 trace_start()"
+  - name: end_ts
+    type: timestamp
+    required: false
+    description: "分析结束时间戳(ns)，默认 trace_end()"
+  - name: min_cpu_ns
+    type: integer
+    required: false
+    default: 0
+    description: "聚合后最小 CPU 时间阈值(ns)"
+  - name: top_k
+    type: integer
+    required: false
+    default: 10
+    description: "返回 TopK 条目"
+
+display:
+  level: detail
+  layer: list
+  title: "进程 Slice CPU 热点"
+  columns:
+    - name: process_name
+      label: "进程"
+      type: string
+      format: truncate
+    - name: slice_name
+      label: "Slice"
+      type: string
+      format: truncate
+    - name: count
+      label: "次数"
+      type: number
+      format: compact
+    - name: thread_count
+      label: "线程数"
+      type: number
+      format: compact
+    - name: sample_threads
+      label: "样例线程"
+      type: string
+      format: truncate
+    - name: total_cpu_ms
+      label: "CPU时间"
+      type: duration
+      format: duration_ms
+      unit: ms
+    - name: total_wall_ms
+      label: "Wall时间"
+      type: duration
+      format: duration_ms
+      unit: ms
+    - name: avg_cpu_ms
+      label: "平均CPU"
+      type: duration
+      format: duration_ms
+      unit: ms
+    - name: max_cpu_ms
+      label: "最大CPU"
+      type: duration
+      format: duration_ms
+      unit: ms
+    - name: cpu_efficiency_pct
+      label: "CPU/Wall"
+      type: percentage
+      format: percentage
+    - name: selected_cpu_share_pct
+      label: "所选CPU占比"
+      type: percentage
+      format: percentage
+    - name: first_ts
+      label: "首次出现"
+      type: timestamp
+    - name: last_ts
+      label: "最后出现"
+      type: timestamp
+
+sql: |
+  WITH
+  raw_input AS (
+    SELECT
+      COALESCE(${start_ts}, trace_start()) AS raw_start_ts,
+      COALESCE(${end_ts}, trace_end()) AS raw_end_ts,
+      ${upid} AS target_upid,
+      NULLIF(COALESCE(NULLIF('${process_name|}', ''), NULLIF('${package|}', '')), '') AS target_process,
+      NULLIF('${slice_name|}', '') AS target_slice,
+      CASE
+        WHEN '${thread_scope|all}' IN ('all', 'main', 'render', 'main_render') THEN '${thread_scope|all}'
+        ELSE 'all'
+      END AS thread_scope,
+      MAX(COALESCE(${min_cpu_ns|0}, 0), 0) AS min_cpu_ns,
+      MIN(MAX(COALESCE(${top_k|10}, 10), 1), 100) AS top_k
+  ),
+  input AS (
+    SELECT
+      MIN(raw_start_ts, raw_end_ts) AS start_ts,
+      MAX(raw_start_ts, raw_end_ts) AS end_ts,
+      target_upid,
+      target_process,
+      target_slice,
+      thread_scope,
+      min_cpu_ns,
+      top_k
+    FROM raw_input
+  ),
+  target_threads AS (
+    SELECT
+      p.upid,
+      p.pid,
+      p.name AS process_name,
+      t.utid,
+      t.tid,
+      COALESCE(t.name, '') AS thread_name
+    FROM process p
+    JOIN thread t ON t.upid = p.upid
+    CROSS JOIN input i
+    WHERE (
+        (
+          i.target_upid IS NOT NULL
+          AND p.upid = i.target_upid
+        )
+        OR (
+          i.target_upid IS NULL
+          AND (
+            i.target_process IS NULL
+            OR p.name GLOB i.target_process || '*'
+            OR p.name LIKE '%' || i.target_process || '%'
+          )
+        )
+      )
+      AND (
+        i.thread_scope = 'all'
+        OR (
+          i.thread_scope IN ('main', 'main_render')
+          AND (t.is_main_thread = 1 OR t.tid = p.pid)
+        )
+        OR (
+          i.thread_scope IN ('render', 'main_render')
+          AND (
+            t.name = 'RenderThread'
+            OR t.name = 'GPU completion'
+            OR t.name GLOB '[0-9]*.ui'
+            OR t.name GLOB '[0-9]*.raster'
+          )
+        )
+      )
+  ),
+  candidate_slices AS (
+    SELECT
+      s.id,
+      s.name AS slice_name,
+      s.ts,
+      s.dur,
+      tt.upid,
+      tt.process_name,
+      tt.utid,
+      tt.thread_name
+    FROM slice s
+    JOIN thread_track track ON s.track_id = track.id
+    JOIN target_threads tt ON track.utid = tt.utid
+    CROSS JOIN input i
+    WHERE s.dur > 0
+      AND s.ts < i.end_ts
+      AND s.ts + s.dur > i.start_ts
+      AND (
+        i.target_slice IS NULL
+        OR (
+          INSTR(i.target_slice, '%') > 0
+          AND s.name LIKE i.target_slice
+        )
+        OR (
+          INSTR(i.target_slice, '%') = 0
+          AND INSTR(s.name, i.target_slice) > 0
+        )
+      )
+  ),
+  per_slice_cpu AS (
+    SELECT
+      cs.id,
+      cs.process_name,
+      cs.slice_name,
+      cs.utid,
+      cs.thread_name,
+      MAX(cs.ts, i.start_ts) AS clipped_start_ts,
+      MIN(cs.ts + cs.dur, i.end_ts) AS clipped_end_ts,
+      MIN(cs.ts + cs.dur, i.end_ts) - MAX(cs.ts, i.start_ts) AS wall_ns,
+      COALESCE(SUM(
+        MIN(MIN(cs.ts + cs.dur, i.end_ts), ts.ts + ts.dur)
+        - MAX(MAX(cs.ts, i.start_ts), ts.ts)
+      ), 0) AS cpu_ns
+    FROM candidate_slices cs
+    CROSS JOIN input i
+    LEFT JOIN thread_state ts ON ts.utid = cs.utid
+      AND ts.state = 'Running'
+      AND ts.dur > 0
+      AND ts.ts < MIN(cs.ts + cs.dur, i.end_ts)
+      AND ts.ts + ts.dur > MAX(cs.ts, i.start_ts)
+    GROUP BY
+      cs.id,
+      cs.process_name,
+      cs.slice_name,
+      cs.utid,
+      cs.thread_name,
+      cs.ts,
+      cs.dur,
+      i.start_ts,
+      i.end_ts
+  ),
+  aggregate_cpu AS (
+    SELECT
+      process_name,
+      slice_name,
+      COUNT(*) AS count,
+      COUNT(DISTINCT utid) AS thread_count,
+      SUBSTR(GROUP_CONCAT(DISTINCT COALESCE(NULLIF(thread_name, ''), '<unnamed>')), 1, 240) AS sample_threads,
+      SUM(cpu_ns) AS total_cpu_ns,
+      SUM(wall_ns) AS total_wall_ns,
+      AVG(cpu_ns) AS avg_cpu_ns,
+      MAX(cpu_ns) AS max_cpu_ns,
+      MIN(clipped_start_ts) AS first_ts,
+      MAX(clipped_end_ts) AS last_ts
+    FROM per_slice_cpu
+    GROUP BY process_name, slice_name
+    HAVING SUM(cpu_ns) >= (SELECT min_cpu_ns FROM input)
+  ),
+  selected_total AS (
+    SELECT SUM(total_cpu_ns) AS total_cpu_ns
+    FROM aggregate_cpu
+  )
+  SELECT
+    process_name,
+    slice_name,
+    count,
+    thread_count,
+    sample_threads,
+    ROUND(total_cpu_ns / 1e6, 2) AS total_cpu_ms,
+    ROUND(total_wall_ns / 1e6, 2) AS total_wall_ms,
+    ROUND(avg_cpu_ns / 1e6, 2) AS avg_cpu_ms,
+    ROUND(max_cpu_ns / 1e6, 2) AS max_cpu_ms,
+    ROUND(100.0 * total_cpu_ns / NULLIF(total_wall_ns, 0), 1) AS cpu_efficiency_pct,
+    ROUND(100.0 * total_cpu_ns / NULLIF((SELECT total_cpu_ns FROM selected_total), 0), 1) AS selected_cpu_share_pct,
+    printf('%d', first_ts) AS first_ts,
+    printf('%d', last_ts) AS last_ts
+  FROM aggregate_cpu
+  WHERE total_cpu_ns > 0
+  ORDER BY total_cpu_ns DESC
+  LIMIT (SELECT top_k FROM input)
+
+output:
+  format: structured

package/skills/atomic/startup_slow_reasons.skill.yaml

@@ -71,17 +71,96 @@ steps:
           type: duration
           format: duration_ms
           unit: ms
+        - name: ts
+          label: "启动开始时间(ns)"
+          type: timestamp
+          hidden: true
+        - name: dur
+          label: "启动耗时(ns)"
+          type: duration
+          hidden: true
+        - name: upid
+          label: "进程UPID"
+          type: number
+          hidden: true
     sql: |
+      WITH startup_type_signals AS (
+        SELECT
+          st.startup_id,
+          MAX(CASE WHEN sl.name = 'bindApplication' THEN 1 ELSE 0 END) as has_bind_app,
+          MAX(CASE WHEN sl.name GLOB 'performCreate:*' THEN 1 ELSE 0 END) as has_perform_create,
+          MAX(CASE WHEN sl.name GLOB 'handleRelaunchActivity*'
+                   OR sl.name GLOB 'relaunchActivity*' THEN 1 ELSE 0 END) as has_relaunch
+        FROM android_startup_threads st
+        JOIN thread_track tt ON tt.utid = st.utid
+        JOIN slice sl ON sl.track_id = tt.id
+        WHERE st.is_main_thread = 1
+          AND sl.ts + sl.dur > st.ts AND sl.ts < st.ts + st.dur
+          AND (sl.name = 'bindApplication'
+               OR sl.name GLOB 'performCreate:*'
+               OR sl.name GLOB 'handleRelaunchActivity*'
+               OR sl.name GLOB 'relaunchActivity*')
+        GROUP BY st.startup_id
+      ),
+      process_age AS (
+        SELECT
+          s.startup_id,
+          MAX(CASE
+            WHEN p.start_ts IS NOT NULL
+              AND p.start_ts >= s.ts - 5000000000
+              AND p.start_ts <= s.ts + s.dur
+            THEN 1 ELSE 0
+          END) as process_created_during_startup
+        FROM android_startups s
+        LEFT JOIN android_startup_processes asp ON asp.startup_id = s.startup_id
+        LEFT JOIN process p ON p.upid = asp.upid
+        GROUP BY s.startup_id
+      ),
+      startup_process AS (
+        SELECT startup_id, MAX(upid) as upid
+        FROM android_startup_processes
+        GROUP BY startup_id
+      ),
+      validated AS (
+        SELECT
+          s.startup_id,
+          s.package,
+          s.ts,
+          CASE
+            WHEN COALESCE(sts.has_bind_app, 0) = 1 THEN 'cold'
+            WHEN COALESCE(sts.has_perform_create, 0) = 1 AND COALESCE(sts.has_bind_app, 0) = 0 THEN 'warm'
+            WHEN COALESCE(sts.has_relaunch, 0) = 1 THEN 'warm'
+            WHEN COALESCE(pa.process_created_during_startup, 0) = 1 THEN 'cold'
+            ELSE s.startup_type
+          END as startup_type,
+          s.dur,
+          ttd.time_to_initial_display,
+          ttd.time_to_full_display,
+          COALESCE(sp.upid, (
+            SELECT p2.upid
+            FROM process p2
+            WHERE p2.name GLOB s.package || '*'
+            ORDER BY p2.start_ts DESC
+            LIMIT 1
+          )) as upid
+        FROM android_startups s
+        LEFT JOIN startup_process sp ON sp.startup_id = s.startup_id
+        LEFT JOIN android_startup_time_to_display ttd USING (startup_id)
+        LEFT JOIN startup_type_signals sts USING (startup_id)
+        LEFT JOIN process_age pa USING (startup_id)
+      )
       SELECT
-        s.startup_id,
-        s.package,
-        s.startup_type,
-        ROUND(s.dur / 1e6, 1) as dur_ms,
-        ROUND(ttd.time_to_initial_display / 1e6, 1) as ttid_ms,
-        ROUND(ttd.time_to_full_display / 1e6, 1) as ttfd_ms
-      FROM android_startups s
-      LEFT JOIN android_startup_time_to_display ttd USING (startup_id)
-      ORDER BY s.dur DESC
+        startup_id,
+        package,
+        startup_type,
+        ts,
+        dur,
+        upid,
+        ROUND(dur / 1e6, 1) as dur_ms,
+        ROUND(time_to_initial_display / 1e6, 1) as ttid_ms,
+        ROUND(time_to_full_display / 1e6, 1) as ttfd_ms
+      FROM validated
+      ORDER BY dur DESC
     save_as: startup_overview
     optional: true
 
@@ -91,6 +170,7 @@ steps:
   - id: slow_reason_checks
     type: atomic
     name: "慢启动原因检测"
+    condition: startup_overview.data.length > 0
     display:
       level: key
       layer: list
@@ -113,11 +193,16 @@ steps:
           type: string
     sql: |
       WITH startup_info AS (
-        SELECT s.startup_id, s.package, s.ts, s.dur, s.startup_type,
-               p.upid
-        FROM android_startups s
-        JOIN process p ON p.name GLOB s.package || '*'
-        ORDER BY s.dur DESC LIMIT 1
+        SELECT
+          startup_id,
+          package,
+          ts,
+          dur,
+          startup_type,
+          upid
+        FROM ${startup_overview}
+        ORDER BY dur DESC
+        LIMIT 1
       ),
       main_thread AS (
         SELECT t.utid, t.tid FROM thread t
@@ -310,7 +395,7 @@ steps:
             JOIN thread_track tt2 ON ba.track_id = tt2.id
             JOIN main_thread mt2 ON tt2.utid = mt2.utid
             WHERE ba.name = 'bindApplication'
-              AND ba.ts >= si.ts AND ba.ts < si.ts + si.dur
+              AND ba.ts + ba.dur > si.ts AND ba.ts < si.ts + si.dur
           )
       ) WHERE cp_count > 3
 
@@ -341,7 +426,7 @@ steps:
             JOIN thread_track tt2 ON ba.track_id = tt2.id
             JOIN main_thread mt2 ON tt2.utid = mt2.utid
             WHERE ba.name = 'bindApplication'
-              AND ba.ts >= si.ts AND ba.ts < si.ts + si.dur
+              AND ba.ts + ba.dur > si.ts AND ba.ts < si.ts + si.dur
               AND ts_inner.ts >= ba.ts AND ts_inner.ts < ba.ts + ba.dur
           ) THEN ts_inner.dur ELSE 0 END) > SUM(ts_inner.dur) / 2 THEN 1 ELSE 0 END as in_bind_app,
           -- SR04 是否已覆盖：futex wait 中有多少被 Lock contention slice 时间重叠解释
@@ -410,7 +495,7 @@ steps:
         FROM slice ba
         JOIN thread_track tt_ba ON ba.track_id = tt_ba.id
         JOIN main_thread mt_ba ON tt_ba.utid = mt_ba.utid
-        JOIN startup_info si ON ba.ts >= si.ts AND ba.ts < si.ts + si.dur
+        JOIN startup_info si ON ba.ts + ba.dur > si.ts AND ba.ts < si.ts + si.dur
         JOIN slice s ON s.track_id = ba.track_id
           AND s.ts >= ba.ts AND s.ts < ba.ts + ba.dur
           AND s.dur > 5000000  -- > 5ms

package/skills/composite/startup_analysis.skill.yaml

@@ -131,6 +131,22 @@ steps:
         - name: type_display
           label: "启动类型"
           type: string
+        - name: startup_type
+          label: "修正后类型"
+          type: string
+          hidden: true
+        - name: original_type
+          label: "原始类型"
+          type: string
+          hidden: true
+        - name: type_reclassified
+          label: "类型已修正"
+          type: number
+          hidden: true
+        - name: type_confidence
+          label: "类型置信度"
+          type: string
+          hidden: true
         - name: dur_ms
           label: "耗时"
           type: duration

package/strategies/anr.strategy.md

@@ -108,7 +108,7 @@ fetch_artifact(artifactId, detail="rows", offset=0, limit=50)
 |--------|------|------|--------|
 | Q4 Sleeping 极高 | >80% | **主线程被阻塞**（ANR 最常见原因） | → 第二步：用 blocked_functions 定位 |
 | Q3 Runnable 高 | >30% | CPU 饥饿——可运行但得不到 CPU | → 检查 `sched_latency`、`cpu_health`、后台进程抢占 |
-| Q1+Q2 Running 高 | >70% | CPU-bound——主线程在执行重计算 | → 检查 `main_thread_slices`、热点函数 |
+| Q1+Q2 Running 高 | >70% | CPU-bound——主线程在执行重计算 | → 检查 `main_thread_slices`，并调用 `invoke_skill("process_slice_cpu_hotspots", { process_name, start_ts, end_ts, thread_scope: "main" })` 定位主线程热点函数/slice 的 Running CPU time |
 | 混合 | 无明显主导 | 多因素共同导致 | → 依次排查 Q4→Q3→Q1 |
 
 ### 第二步：当 Q4 占比高时 — 用 blocked_functions + 线程状态定位
@@ -197,4 +197,4 @@ fetch_artifact(artifactId, detail="rows", offset=0, limit=50)
 - 忽略 `wakeup_chain` 数据（这是定位间接依赖链的关键）
 - 把所有 ANR 统一用同一个决策路径分析，不区分 ANR 类型
 - 忽略 `app_freeze_check`（应用完全冻结 vs 部分响应是重要区分）
-- 不交叉检查 CPU/内存/IO 系统上下文就下结论
+- 不交叉检查 CPU/内存/IO 系统上下文就下结论

package/strategies/game.strategy.md

@@ -100,7 +100,7 @@ invoke_skill("mali_gpu_power_state")
 | CPU 频率下降 | `invoke_skill("thermal_throttling")` | 游戏长时间运行容易触发热节流 |
 | 内存压力 | `invoke_skill("memory_analysis")` | 游戏内存占用大，可能触发 LMK |
 | CPU 调度 | `invoke_skill("cpu_analysis")` | 游戏线程调度到小核会造成帧率波动 |
-| 线程/进程 CPU 利用率 | `invoke_skill("cpu_thread_utilization_period")` / `invoke_skill("cpu_process_utilization_period")` | 判断 UnityMain/GameThread/RenderThread 是否 CPU-bound |
+| 线程/进程 CPU 利用率 | `invoke_skill("cpu_thread_utilization_period")` / `invoke_skill("cpu_process_utilization_period")`；需要函数/slice 级热点时补 `invoke_skill("process_slice_cpu_hotspots", { process_name, start_ts, end_ts })` | 判断 UnityMain/GameThread/RenderThread 是否 CPU-bound，并用 Running CPU time 定位 named slice 热点 |
 | 功耗归因 | `invoke_skill("wattson_thread_power_attribution")` | 仅在 power_rails + cpu_freq_idle 可用时做线程能耗归因 |
 | 独立 GL swap 间隔 | `invoke_skill("gl_standalone_swap_jank")` | NativeActivity/GLSurfaceView 或引擎自管 swap 时检查生产端 present 节奏 |
 

package/strategies/general.strategy.md

@@ -19,7 +19,7 @@ keywords: []
 
 | 用户关注方向 | 推荐路径 | 说明 |
 |-------------|---------|------|
-| **CPU / 调度 / 线程** | `invoke_skill("cpu_analysis")` → 如果发现 throttling → `invoke_skill("thermal_throttling")` | 交叉检查热节流和 CPU 频率 |
+| **CPU / 调度 / 线程** | `invoke_skill("cpu_analysis")` → 需要函数/slice CPU 热点时 `invoke_skill("process_slice_cpu_hotspots", { process_name: "<包名或进程名>" })` → 如果发现 throttling → `invoke_skill("thermal_throttling")` | 用 Running CPU time 区分真实计算热点和 wall-time 阻塞，再交叉检查热节流和 CPU 频率 |
 | **内存 / OOM / 泄漏** | `invoke_skill("memory_analysis")` → 如果有 heap dump → `invoke_skill("android_heap_graph_summary")` → 如果有 LMK → `invoke_skill("lmk_analysis")` → 如果涉及 GPU 内存 → `invoke_skill("dmabuf_analysis")` | 层层深入内存问题；heap graph 用 retained/cumulative size 定位 retainer |
 | **IO / 磁盘 / 存储** | `invoke_skill("block_io_analysis")` 或 `invoke_skill("io_pressure")` | 磁盘 IO 和系统 IO 压力 |
 | **GPU / 渲染** | `invoke_skill("gpu_analysis")` | GPU 频率、利用率、Fence 等待 |

package/strategies/prompt-openai-final-report-continuation-en.template.md

@@ -0,0 +1,12 @@
+<!-- SPDX-License-Identifier: AGPL-3.0-or-later -->
+<!-- Copyright (C) 2024-2026 Gracker (Chris) | SmartPerfetto -->
+
+System check: every analysis phase is completed/skipped, but there is still no complete user-facing final report.
+
+Now output only the final report body. The first line must be `## Final Conclusion`. Do not call tools, do not call update_plan_phase, do not narrate the process, and do not output phase-by-phase logs.
+
+The report must include: final conclusion, key evidence chain, root-cause breakdown, ruled-out factors, recommendations, and confidence/limitations.
+
+Do not merely restate phase summaries; synthesize the collected concrete values and evidence into a readable conclusion.
+
+Length requirement: at most 700 English words. Use 2-3 bullets per section; do not expand into a phase-by-phase log, do not copy artifact tables, do not output the evidence table index, and do not repeat raw SQL. If the evidence is sufficient, conclude directly.

package/strategies/prompt-openai-final-report-continuation-zh.template.md

@@ -0,0 +1,12 @@
+<!-- SPDX-License-Identifier: AGPL-3.0-or-later -->
+<!-- Copyright (C) 2024-2026 Gracker (Chris) | SmartPerfetto -->
+
+系统校验：所有分析阶段已经 completed/skipped，但当前还没有面向用户的完整最终报告。
+
+请现在只输出最终报告正文；第一行必须是 `## 综合结论`。不要再调用工具，不要再调用 update_plan_phase，不要解释过程，不要输出“验证逻辑/现在进入 Phase/完成综合结论输出/分阶段证据摘要”。
+
+报告必须包含：综合结论、关键证据链、根因拆解、已排除因素、优化建议、置信度/限制。
+
+不要只复述阶段摘要；必须把已采集到的具体数值和证据串成可读结论。
+
+长度要求：最多 1200 个中文字符。每个小节 2-3 条要点即可；不要展开逐阶段流水账，不要复制 artifact 表格，不要重复 SQL 原文，不要输出证据表索引。若证据已经足够，直接收束。

package/strategies/prompt-output-format.template.md

@@ -84,7 +84,7 @@ graph LR
 ```
 
 ### 结论结构
-结论必须完整但克制：优先输出能支撑决策的证据链，避免把已经展示过的大表逐行搬进最终报告。目标长度控制在约 6000 中文字符内；如果证据很多，用聚合表和证据索引压缩，不要生成会在 token 上限处截断的超长报告。
+结论必须完整但克制：优先输出能支撑决策的证据链，避免把已经展示过的大表逐行搬进最终报告。中文目标长度控制在约 2500-3500 字符，英文目标长度控制在约 1200-1800 words；如果证据很多，用聚合表和证据索引压缩，不要生成会在 token 上限处截断的超长报告。
 
 1. **概览**: 一句话总结性能状况。如果架构检测置信度 < 80%，在概览中标注（如"⚠️ 架构检测置信度 50%，分析策略可能不完全匹配"），帮助用户理解分析的局限性
 2. **关键发现**: 按严重程度排列的发现列表（含根因推理链 + 📚 背景知识）

package/strategies/scrolling.strategy.md

@@ -224,6 +224,7 @@ invoke_skill("scrolling_analysis", { start_ts: "<trace_start>", end_ts: "<trace_
 | UI thread 时间分解 | `invoke_skill("frame_ui_time_breakdown")` | 看 UI thread 在每帧的耗时分布 |
 | 每帧阻塞调用 | `invoke_skill("frame_blocking_calls")` | 将掉帧帧与 Binder/GC/锁竞争/futex/文件 IO 阻塞区间做重叠匹配 |
 | CPU process/thread 周期利用率 | `invoke_skill("cpu_process_utilization_period")` / `invoke_skill("cpu_thread_utilization_period")` | 用于 workload_heavy、后台抢占、线程归因 |
+| 进程 slice CPU 热点 | `invoke_skill("process_slice_cpu_hotspots", { process_name, start_ts, end_ts })` | 用 `thread_state=Running` 求交，确认掉帧窗口内真正消耗 CPU 的 named slice |
 | CPU cluster 拓扑 | `invoke_skill("cpu_cluster_mapping_view")` | 解释大小核分布，辅助 small_core_placement |
 | GPU work period | `invoke_skill("android_gpu_work_period_track")` | 只有 `gpu_work_period` capability 可用时才做 GPU active region 判断 |
 | Mali power state | `invoke_skill("mali_gpu_power_state")` | Mali 设备专用；无数据时标注设备/trace 不支持 |

package/strategies/startup.strategy.md

@@ -102,12 +102,14 @@ plan_template:
 | 热启动 (hot) | 两者均不存在 → 保留 Perfetto 原始分类 | Activity.onRestart() → onStart() → onResume() |
 
 **判定逻辑（优先级从高到低）：**
-1. 如果 Skill 返回的 `startup_type` 已经过重分类（`startup_events_in_range` 的 SQL 层重分类），直接信任
+1. 如果 Skill 返回的 `startup_type/type_display` 已经过重分类（`startup_events_in_range` 的 SQL 层重分类，或 `startup_quality.issue_codes` 包含 `R009_TYPE_RECLASSIFIED`），直接信任；除非同一条 SQL 明确复现了 Skill 的 overlap 口径并证明修正信号不存在，否则不得推翻。
 2. 否则检查 trace 信号：`bindApplication` 存在 → cold；仅 `performCreate:*` 存在 → warm；均无 → hot
 3. 热启动无正向信号（没有专属的 trace slice），仅靠排除法判定——这是合理的，因为热启动不触发 Activity 重建
 
 **⚠️ LMK 边界场景：** 进程被 LMK 回收后重启时，ActivityManager 可能仍持有 Activity 记录，导致 Perfetto 报告 `warm`。但 `bindApplication` slice 存在说明进程经历了完整初始化（Zygote fork → handleBindApplication），实为 cold start。此时**必须以 `bindApplication` 信号为准**，覆盖 Perfetto 原始分类。
 
+**⚠️ 验证口径陷阱：** `bindApplication` 可能早于 `android_startups.ts` 约几十到数百毫秒开始。用 `thread_slice.ts BETWEEN start_ts AND end_ts` 的窄窗口查询返回 0 行，不能证明 `bindApplication` 不存在。若要自行验证，必须使用 `android_startup_threads` 与 `slice` 的 overlap 条件（`sl.ts + sl.dur > st.ts AND sl.ts < st.ts + st.dur`），或至少把起点扩展到 `start_ts - 500ms`。当 `startup_analysis` 已给出 `type_display=冷启动`、`type_reclassified=1`、`startup_breakdown.reason=bind_application` 或 `R009_TYPE_RECLASSIFIED` 时，结论必须按冷启动写，不得输出“R009 误判/维持温启动”。
+
 #### 启动场景关键 Stdlib 表
 
 写 execute_sql 时优先使用（完整列表见方法论模板）：`android_startup_opinionated_breakdown`、`android_garbage_collection_events`、`android_oom_adj_intervals`、`android_screen_state`、`slice_self_dur`、`cpu_process_utilization_in_interval(ts, dur)`、`cpu_frequency_counters`、`android_dvfs_counter_stats`
@@ -131,6 +133,7 @@ invoke_skill("startup_analysis", { enable_startup_details: false })
   可能的根因：异步帧渲染排队、SurfaceFlinger 合成延迟、GPU 渲染耗时、dequeueBuffer 等待。结论中必须量化说明 gap 中各阶段的耗时占比。
 - **R009_TYPE_RECLASSIFIED**（启动类型重分类）：如果温启动存在 bindApplication slice，说明进程实际被重建过，可能是冷启动被误分类。分析时应质疑启动类型并说明重分类依据。
 - **温启动 + bindApplication 矛盾**：即使未触发 R009，如果主线程热点中出现 bindApplication（478ms+），也应主动质疑：温启动不应有 Application 初始化开销。可能原因：① 进程被回收后重启（实为冷启动）；② framework atrace 标记不准确。
+- **禁止反向误判**：如果 `startup_analysis.get_startups` 显示 `type_display=冷启动`，且 `startup_breakdown` 包含 `bind_application` 耗时，后续任何 raw SQL 只有在使用 overlap/扩展窗口并命中同一进程主线程后，才允许挑战冷启动结论。窄窗口 0 行只能写成“该 SQL 口径未覆盖 bindApplication 起点”，不能写成“bindApplication 不存在”。
 
 **Phase 2 — 获取启动详情（需要传参）：**
 ```