GENERATED FILE - DO NOT EDIT.
Source: docs/rendering_pipelines/S01_rendering_types_overview.md
Source SHA-256: 9e61960d979bd9d5837bcc0976274a1dcaf191ae5d5b65e2c2207bf1b95eb386

# Android Perfetto 系列 - App 出图类型 - 总览与识别方法

这篇给出 App 出图类型的公共基线：Producer 生成 buffer，SurfaceFlinger 采纳 layer 更新并组织合成，Hardware Composer（HWC）和显示设备完成 present。标准 App Window 的 Producer 位于应用进程；Camera、Video、WebView、Flutter、游戏等路径可能把生产工作交给引擎、解码器或硬件模块。

读 Perfetto 时，如果能认出 MainThread、RenderThread、SurfaceFlinger、HWC，却不确定它们在一帧中各自负责哪一段，就需要先建立这条显示路径。

这篇先把四个观察点固定下来：

- 知道标准 App Window 在显示链里主要扮演 **Producer**，而 SurfaceFlinger、HWC 与显示设备负责后续合成和 present
- 知道 `vsync-app`、MainThread、RenderThread、BLASTBufferQueue、SurfaceFlinger、HWC、Display 是怎样一环扣一环接起来的
- 知道 `queueBuffer`、`BufferTX - <layerName>` counter、`acquire fence`、`release fence`、`present fence` 分别处在路径的哪一段
- 知道以后在 Perfetto 上看到某个 App 的出图现象时，应该先问哪些问题、先看哪些层、先查哪些关键轨迹

<!--more-->

## 阅读导航


### 本文目录

- 阅读说明
- 1. 问题起点：为什么先建立显示主线
- 核心图：显示链路总图
- 2. 起帧阶段：一帧如何被 App 叫起来
- 3. 提交阶段：内容如何从 App 进入系统
- 4. 显示阶段：系统如何采纳、合成并送屏
- 5. 排查阶段：把标准路径转成检查顺序
- 6. 源码入口：优先跟读哪里
- 7. 版本演进：Android 12 到 Android 17
- 8. Perfetto 证据：按层观察一帧
- 9. 系列展开：后续文章按哪些分叉继续
- 10. 附录：易混淆概念对照表
- 总结

### 系列文章目录

1. [Android Perfetto 系列 - App 出图类型 - 总览与识别方法](S01_rendering_types_overview.md)
2. [Android Perfetto 系列 - App 出图类型 - AOSP 标准类型](S02_aosp_standard_type.md)
3. [Android Perfetto 系列 - App 出图类型 - SurfaceView 类型](S03_surfaceview_type.md)
4. [Android Perfetto 系列 - App 出图类型 - TextureView 类型](S04_textureview_type.md)
5. [Android Perfetto 系列 - App 出图类型 - 混合出图类型](S05_mixed_rendering_type.md)
6. [Android Perfetto 系列 - App 出图类型 - 多窗口类型](S06_multi_window_type.md)
7. [Android Perfetto 系列 - App 出图类型 - Software / 离屏类型](S07_software_offscreen_type.md)
8. [Android Perfetto 系列 - App 出图类型 - Native Graphics 类型](S08_native_graphics_type.md)
9. [Android Perfetto 系列 - App 出图类型 - WebView 类型](S09_webview_type.md)
10. [Android Perfetto 系列 - App 出图类型 - Flutter 类型](S10_flutter_type.md)
11. [Android Perfetto 系列 - App 出图类型 - Camera 类型](S11_camera_type.md)
12. [Android Perfetto 系列 - App 出图类型 - Video Overlay / HWC 类型](S12_video_overlay_hwc_type.md)
13. [Android Perfetto 系列 - App 出图类型 - Game 类型](S13_game_type.md)
14. [Android Perfetto 系列 - App 出图类型 - React Native 类型](S14_react_native_type.md)

## 阅读说明


作为整组文章的公共说明，这里先定义后续反复出现的对象、帧节奏和系统角色。

如果已经比较熟悉 Perfetto，这篇更像是在补“显示过程总图”；如果对工具还不熟，也没关系，因为本文先讲的是一帧怎样往前走，不要求先熟练操作界面。

后续 S02–S14 会分别分析不同出图类型；这里建立最常见的公共显示过程。平台源码固定到 Android 17 / API 37 的 `android-17.0.0_r1`，kernel 源码固定到 `android17-6.18-2026-06_r6`。S01 的主线位于 framework、HWUI、SurfaceFlinger 和 HWC，本篇没有依赖某个 kernel 函数得出结论；涉及 dma-buf、sync fence、DRM/KMS 等 kernel 实现时，仍以这个 kernel tag 为准。旧版本实现只用于解释概念演进。

## 1. 问题起点：为什么先建立显示主线


只按控件名或框架名记路径，到了 Perfetto 里仍然容易找错对象。`SurfaceView`、`TextureView`、`WebView`、`Flutter` 描述的是 API 或框架，不能直接回答“谁生产 buffer、buffer 进入哪个 Surface、是否形成独立 layer、由谁完成最终合成”。以 Flutter 为例，渲染视图可以使用 `SurfaceView` 或 `TextureView`，PlatformView 还会引入 Hybrid Composition、Texture Layer 或 Virtual Display 等不同路径。trace 里同时出现应用线程、引擎线程、BufferQueue、SurfaceFlinger 和 HWC；诊断要先确认本帧经过了哪些对象。

Perfetto 里会看到 `vsync-app`、MainThread 的 Input / Animation / Traversal、RenderThread 的 `DrawFrame`、BLASTBufferQueue 的 buffer 周转、SurfaceFlinger 的 transaction 与 composition，以及 HWC 和显示设备的 present。每个信号只说明一段工作发生过，不能单独证明用户已经看到这一帧。

比如：

- `queueBuffer` 已经发生了，画面却还是晚了一帧；
- 应用线程看起来不算忙，FrameTimeline 却已经偏了；
- 问题可能不在 GPU，而在 SurfaceFlinger 等待 buffer 或等待 present 的时机；
- App 已经“画完了”，但系统侧这一轮还没把它拿去合成。

总览篇先固定这些对象的位置和边界。后续分析不同出图类型时，再检查 Producer、Surface、layer 或合成位置从哪个节点开始变化。

## 显示链路总图


**这张图是本系列的基线参考。** 一帧从 App 觉得要更新，到 Android 显示栈可观察的 present 边界，会依次走过 12 个关键节点；后续 S02–S14 讲各种出图类型时，都会指出它在这 12 个节点里的哪一段偏离基线。这里的 present 边界不等于 panel 光学响应，也不等于用户视觉感知。

```mermaid
sequenceDiagram
    participant MT as App MainThread
    participant RT as App RenderThread
    participant BBQ as BLASTBufferQueue
    participant GPU as App GPU queue
    participant SF as SurfaceFlinger FrontEnd / CompositionEngine
    participant HWC as HWComposer / Composer HAL
    participant DD as Display driver

    Note over MT,GPU: ①–⑥ 应用生产阶段

    SF->>MT: ① vsync-app（由预测 present time 反推 app wakeup）
    MT->>MT: ② Choreographer.doFrame<br/>INPUT → ANIMATION → INSETS_ANIMATION → TRAVERSAL → COMMIT
    MT->>RT: ③ syncAndDrawFrame（同步本帧 RenderNode 树状态）
    RT->>BBQ: ④ dequeueBuffer（从 BBQ 取一块 buffer；可能等 release fence）
    RT->>GPU: ⑤ Skia pipeline → GPU 命令提交
    RT->>BBQ: ⑥ queueBuffer（附 producer completion fence；Consumer 侧作为 acquire fence）
    BBQ->>SF: ⑥' Transaction::setBuffer/apply（SF server 计入 pending 后 BufferTX - layerName +1）

    Note over SF,DD: ⑦–⑫ 系统合成与显示阶段

    DD-->>SF: ⑦ HW VSync sample / mode timing<br/>Scheduler 按 sf workDuration 起跑
    SF->>SF: ⑧ 消费 transaction → 更新 snapshot<br/>选择 buffer 并检查 acquire fence
    SF->>HWC: ⑨ 提交可见 layer、buffer、fence 与属性
    alt 允许 skip validate
        SF->>HWC: presentOrValidateDisplay
        HWC-->>SF: PresentSucceeded（已保存 fences）或 Validated
    else 普通 validate
        SF->>HWC: validateDisplay
        HWC-->>SF: changed composition types / requests
    end
    opt validate / Validated 返回状态调整
        SF->>HWC: acceptChanges
    end
    opt 需要 CLIENT composition
        SF->>GPU: ⑩ RenderEngine 生成 client target
        SF->>HWC: setClientTarget（client target acquire fence）
    end
    opt 当前轮尚未 present
        SF->>HWC: ⑪ presentDisplay
        HWC-->>SF: present fence fd + layer release fence fds
    end
    HWC->>DD: 提交 display frame
    DD-->>SF: ⑫ present fence 稍后异步 signal
    SF-->>BBQ: per-layer release fence / release callback
    BBQ-->>RT: release fence signal 后旧 buffer 可复用
```

> 标准 App Window 路径下，**BLASTBufferQueue（BBQ）位于 App 进程**。RenderThread 通过 `Surface` 使用其 BufferQueue Producer；BLAST 的 Consumer 回调在同一进程取出 `BufferItem`，调用 `Transaction::setBuffer()` 并 `apply()`，再把 buffer update 送到 SurfaceFlinger。窗口几何或同步事务可以按 frame number 与这笔 buffer transaction 合并。Perfetto 中的 `BufferTX - <layerName>` counter 在 SurfaceFlinger server 侧收到 pending buffer update 后变化；`queueBuffer` 返回时不保证 counter 已经加一，counter 也不表示 position、crop、alpha 每帧都在改变。`SurfaceView` 等独立 Surface 还会增加自己的 layer 和 Producer，S03 会单独说明。

注意：本文圆圈编号是固定基线锚点。后续文章如果使用普通 `1.` / `2.` 的流程编号，那是各自场景里的叙述顺序，不和这里的 ①–⑫ 强制一一对应。`⑥'` 是紧贴 ⑥ 的服务端观测点，用来提醒 `BufferTX - <layerName>` 属于 SF server 侧 pending buffer 变化，不额外算成新的主锚点。正文后续把它简称为 `BufferTX` 时，仍指这条 per-layer counter。

### 图解 1：12 个主锚点

| 编号 | 节点 | 所属阶段 |
|:----:|------|---------|
| ① | `vsync-app` 触发 | 帧起点 |
| ② | `Choreographer.doFrame`（5 段 callback） | 主线程 |
| ③ | `syncAndDrawFrame`（UI 线程向 RenderThread 同步本帧树状态） | 主线程 / RenderThread 边界 |
| ④ | RenderThread `dequeueBuffer` | 生产 |
| ⑤ | Skia pipeline / GPU 提交 | 生产 |
| ⑥ | App / RT `queueBuffer` 到 BBQ，随 buffer 附上 producer completion fence；进入 Consumer / SF 侧后作为 acquire fence | 提交 |
| ⑥' | SF server 收到含 buffer 的 Transaction 并计入 pending，此时 `BufferTX - <layerName>` +1；latch 或 drop 后 -1 | 服务端观测点 |
| ⑦ | `vsync-sf` 触发 SF | SF 帧起点 |
| ⑧ | SF latch（检查 / 等待 acquire fence；特定条件可 latch unsignaled） | 合成 |
| ⑨ | HWC strategy：可 skip validate 时才尝试 `presentOrValidate`；PresentSucceeded 表示组合 HAL 调用走了 present 分支并返回 fence，Validated 进入 `getChangedCompositionTypes` / `acceptChanges`；否则走 `validateDisplay` slow path | 合成 |
| ⑩ | GPU client composition + `setClientTarget`（按需） | 合成 |
| ⑪ | `presentAndGetReleaseFences`：若 ⑨ 未在 fast path present，则 `presentDisplay`；随后收集 present / release fence fd | 显示 |
| ⑫ | 返回的 present fence 后续异步 signal，作为本轮显示栈 present 的时间锚点；它不等于 panel 像素完成光学响应 | 显示 |

### 图解 2：三条 fence 的流向

- **acquire fence**：Producer 提交 buffer 时会附上表示写入完成时机的 fence；Android 源码里的 `QueueBufferInput` / `BufferData` 在 Consumer / SF 侧把它称为 acquire fence。SF 用它判断 transaction / latch readiness，特定条件下可以 latch unsignaled buffer。读取 buffer 的 GPU / HWC 边界仍必须遵守这条 fence：device composition 时，layer acquire fence 会随 `setLayerBuffer()` 交给 HWC；client composition 时，RenderEngine 消费或等待原 layer 的输入 fence，随后 `setClientTarget()` 附带的是 client target 自己的 acquire fence，不是原 App layer 的那条 fence。标准 HWUI 路径里常见含义是 GPU 写入完成，Camera、Video、Native Graphics 等路径还可能来自解码器、Camera HAL、blitter 或其他硬件模块。
- **present fence**：HWC 在 ⑪ `presentDisplay()` 返回 per-display、per-frame 的 fence fd；如果走 `presentOrValidateDisplay()` fast path，只有 PresentSucceeded 分支才会返回 present fence，Validated 分支会继续 `getChangedCompositionTypes()` / requests / `acceptChanges()`，必要时完成 client composition 后再 present，不会再重复调用 `validateDisplay()`。这个 fd 会在后续 present 到达 Android 显示栈可观察边界时异步 signal。SF 用它回写和校准 present timing，App 侧通常通过 FrameTimeline、FrameMetrics、JankStats 或 Perfetto 观察这一帧的显示时间锚点。
- **release fence**：HWC 在 present 之后通过 `getReleaseFences()` 返回 per-layer、per-frame 的 fence fd，表示上一轮该 layer buffer 何时不再被 HWC 使用。SF 还会按 layer 是否 client-composited、是否仍在当前 output 上做 merge / fallback，再经 release callback / BufferQueue 回传给 Producer；RT 在 ④ 下一次 `dequeueBuffer` 时可能等这条 fence signal 后才复用旧 buffer slot。

这张图和这 12 个编号会被后续 13 篇反复引用。以后遇到具体类型时，先在心里对回这张图的哪一段，再看它的偏离处。

## 2. 起帧阶段：一帧如何被 App 叫起来


从 Android 图形系统的角度看，App 这一半负责的是**按显示节奏把这一帧生产出来**，最终显示的拥有者是 SurfaceFlinger 与显示硬件。生产过程分四个阶段：

1. 发现这一帧有必要更新；
2. 等系统给一个合适的起跑点，也就是 `vsync-app`；
3. MainThread 把这一帧的逻辑状态准备好；
4. RenderThread 或等价生产线程承接这一帧的状态，通过 Skia pipeline 把绘制命令提交给 GPU，再把图形结果交给 buffer 系统。

### 起帧 1：状态变化先进入下一帧调度

应用不会无缘无故每一帧都进入下一帧调度。通常是发生以下事件之后，应用才会进入“下一帧需要更新”的状态：

- 用户有输入；
- 某个动画还在跑；
- 某个 View 调用了 `invalidate()`；
- 某个布局发生变化，需要重新 measure / layout / draw；
- 窗口属性、Insets、可见性、尺寸发生变化。

这一步通常落在 `ViewRootImpl.scheduleTraversals()` 或相关回调调度上。Android 17 中，它会在尚未安排 traversal 时把 `mTraversalCallback` 注册到 `Choreographer.CALLBACK_TRAVERSAL`，再由 `Choreographer` 在没有 pending frame 的情况下请求下一次 VSync。`invalidate()` / `requestLayout()` 触发的是“把工作安排到后续帧”，不是每次调用都无条件申请一份新的 `vsync-app`。

### 起帧 2：`vsync-app` 从系统调度走到 App 进程

对应用来说，可观察到的是 SurfaceFlinger 体系整理后的应用侧 Vsync 事件。可以按这个顺序理解：

1. 显示硬件或者系统的 Vsync 预测逻辑给出下一次显示帧节奏；
2. SurfaceFlinger 的 Scheduler 依据预测 present time、app `workDuration` 和 `readyDuration` 反推出应用侧 wakeup time，通过 `EventThread` 把 `vsync-app` 回调给订阅者（`DisplayEventReceiver`）；
3. 应用进程里的 `DisplayEventReceiver` / `FrameDisplayEventReceiver` 通过系统侧的事件通道和 Looper 机制接到这个事件；
4. `FrameDisplayEventReceiver.onVsync()` 再把这次 Vsync 包装成主线程要处理的消息；
5. 主线程进入 `Choreographer` 的 `doFrame()`（Perfetto 中对应的 slice 名是 `Choreographer#doFrame`），这一帧正式开始。

这里容易看岔：Perfetto 里 SurfaceFlinger 进程的 `vsync-app` counter 在跳，不代表目标 App 已经开始跑这一帧。对具体 App，直接看它自己进程里的 `Choreographer#doFrame` slice 和后续回调。

### 起帧 3：MainThread 先整理输入、动画和布局状态

主线程 Input、Animation、Traversal 这几个阶段要看成一条自然的准备链，而不是互相独立的步骤。

`Choreographer` 在每一个 `vsync-app` 周期里按 callback 类型组织本帧工作。完整顺序是 **`CALLBACK_INPUT` → `CALLBACK_ANIMATION` → `CALLBACK_INSETS_ANIMATION`（Android 11+ 新增，处理系统栏 / 键盘动画）→ `CALLBACK_TRAVERSAL` → `CALLBACK_COMMIT`**。

`INSETS_ANIMATION` 位于 Animation 之后、Traversal 之前，用于把 Input 和 Animation 引起的 Insets 变化合并后再交给 View 树。Vsync 到达后，输入、动画和 Insets 状态会先推进，随后才进入 measure / layout / draw。布局和绘制必须建立在本帧已经确认的用户意图和 UI 状态上。

#### 第一步：Input

如果这一帧前面有触摸、滑动、按键等输入，主线程会先把这一帧该消费的输入处理掉。为什么它必须排在前面？因为输入会直接改变当前 UI 的状态。

比如列表正在跟手滑动，如果这一帧先去 layout，再回头处理输入，位置就会晚一帧。系统把 Input 放在前面，就是为了让这一帧后续的动画、布局、绘制都能基于**最新状态**来做。

普通输入事件本身通过 `InputChannel` / `InputConsumer` 异步送到 UI 线程，并不排队等 Choreographer。`CALLBACK_INPUT` 主要负责 **batched motion events 的帧同步消费 / 重采样**——`ViewRootImpl.scheduleConsumeBatchedInput()` 把 `mConsumedBatchedInputCallback` 注册到 `Choreographer.CALLBACK_INPUT`，随后 `doConsumeBatchedInput()` 调用 `InputEventReceiver.consumeBatchedInputEvents(frameTimeNanos)`，把同一帧内到达的一连串 `ACTION_MOVE` 重采样到本帧精确的 vsync 时刻。普通输入队列仍由 `scheduleProcessInputEvents()` / `doProcessInputEvents()` 异步处理。所以说“Input 排在最前面”，指的是帧同步的 batched input 这一刻，不是说所有输入都要在这里排队。

#### 第二步：Animation

动画阶段根据本帧时间推进属性值、滚动位置或其他连续状态。输入处理排在它前面，因此动画回调可以基于本帧已经消费的输入更新目标。属性动画、`OverScroller` 驱动的惯性滚动以及通过 `postOnAnimation()` 注册的工作，都会在这一阶段出现；没有到期的 Animation callback 时，UI 状态保持不变，不会凭空多做一轮动画计算。

#### 案例：按压滑动与惯性滑动的 callback 差异

初学者常疑惑：为什么列表在手指按住拖动时，这一帧里经常能看到 Input；手一松进入 fling，Input 很快没了，画面却还在继续动。原因是驱动源已经变了。

- 按压滑动：属于手指还在屏幕上的 manual scroll。`ACTION_MOVE` 会先在 Input 阶段被消费，`RecyclerView` 或外层滚动容器根据最新触点计算偏移，再触发 `invalidate()` 或后续布局请求。这一帧的位移源头来自输入。
- 惯性滑动：手指抬起后，不再有新的 `ACTION_MOVE`。列表还能继续动，是因为 `OverScroller` / `Scroller` 这一类对象在 Animation 阶段继续根据速度和阻尼算本帧位移，再触发 `invalidate()`。这一帧的位移源头已经从输入切到动画。

这件事在 Perfetto 上特别重要。手指按住拖动时，通常会先看到 Input 相关 slice；进入 fling 之后，Input 可能很快变轻甚至消失，持续推进位移的是 Animation。如果忽略这个阶段切换，很容易把正常 fling 误看成异常后台任务——列表继续动不需要 Input Callback，驱动源已经切到 Animation。

Input → Animation → Traversal 的顺序让同一帧先消费最新输入，再推进动画状态，随后按更新后的状态布局和绘制，减少输入到画面的额外帧延迟。

#### 第三步：Traversal

Traversal 把 View 树的待处理状态整理成 RenderThread 可以继续消费的绘制状态。三个动作存在依赖关系：

- `measure`：父 View 通过 `MeasureSpec` 给出约束，子 View 返回测量宽高。文字换行、图片尺寸、Insets 变化和父容器约束都可能触发重新测量。
- `layout`：父 View 根据测量结果确定子 View 的 `left`、`top`、`right`、`bottom`。命中测试、裁剪和后续绘制会使用这些几何结果，但 z-order、透明度等属性并不都由 `layout()` 决定。
- `draw`：软件渲染会直接写入目标 Canvas；标准硬件加速路径主要更新 View 对应的 `RenderNode` / DisplayList。这里记录“画什么”，像素工作仍由后续 RenderThread 和 GPU 完成。

尺寸确定后才能放置坐标，绘制记录又依赖最终几何关系，因此顺序固定为 `measure → layout → draw`。这不表示每个 `vsync-app` 都会完整重算整棵树：`performTraversals()` 会根据 layout request、dirty region 和节点状态决定哪些工作需要执行，未变化的 `RenderNode` 可以复用已有 DisplayList。Traversal 耗时不能只用 View 数量解释，还要看本帧哪些子树失效、是否触发重新布局以及录制范围。

#### Traversal 之后：syncAndDrawFrame 交接

在 `CALLBACK_TRAVERSAL` 执行栈末尾，UI 线程通过 `syncAndDrawFrame()` 向 RenderThread 同步本帧状态，RenderThread 上可看到 `DrawFrame` slice。UI 线程会等待 `DrawFrameTask` 完成必要的状态同步；能否在实际 draw 前提早放行，取决于 `syncFrameState()` 返回的条件。这个等待不会持续到 panel 显示完成。

### 起帧 4：RenderThread 把树状态变成 GPU 工作

标准 HWUI 路径里，主线程完成 `Traversal` 后进入 `ViewRootImpl.performDraw()`，调用 `HardwareRenderer.draw()`（`ThreadedRenderer` 继承自它，仍在 UI 线程执行）。`draw()` 内部先更新 root `RenderNode` 的 DisplayList，再通过 `syncAndDrawFrame()` 入口下发；native 侧经 `RenderProxy` 把 `DrawFrameTask` 投递到 RenderThread。这里最重要的结论是：**`syncAndDrawFrame` 是 UI 线程向 RenderThread 交接本帧状态的入口，不等于这一帧已经开始上屏。**

可以按四个步骤观察 `RenderThread` 的工作流程。

#### 第一步：帧状态同步

`DrawFrameTask` 被投到 `RenderThread` 后不会立刻调用 `queueBuffer`。`syncFrameState()` 先把本帧的 `vsync`、`frameDeadline` 等 frame info 交给 RenderThread，应用 deferred layer update，再调用 `CanvasContext::prepareTree()` 处理当前 `RenderNode` 树。完成这一步后，RenderThread 才知道本帧能否绘制、使用哪份节点状态以及哪些纹理或 layer 需要更新。

`syncAndDrawFrame` 里的 `sync`，指的是**把 UI 线程算好的帧状态同步到 RenderThread 能继续处理的位置**，不是同步到屏幕。

#### 第二步：UI 线程的阻塞与放行边界

这个边界容易误判。AOSP 在 `ThreadedRenderer` 注释里写得很直白：UI thread 可以 block 在 RenderThread 上，但 RenderThread 不能反过来 block UI thread。对应到 `DrawFrameTask` 的实现，主线程先 `postAndWait()`；RenderThread 跑完 `syncFrameState()` 之后，如果这一帧允许提早放行 UI thread，就会先 `unblockUiThread()`，否则会等 draw 阶段结束后再放行。**UI thread 等多久，取决于这一帧的同步条件，不是固定只等某一个函数返回。**

Perfetto 里的 `syncAndDrawFrame` 表示 UI 线程与 RenderThread 的同步边界。绘制执行、GPU command submission 和 buffer 提交还会继续发生，不能用这个 slice 的结束时间代替 App frame 完成时间。

#### 第三步：绘制执行与 GPU 提交

状态同步完之后，`CanvasContext::draw()` 才进入绘制执行与提交阶段。这里可以粗略抓四件事：

1. 计算 dirty 区域，确认这一帧有没有内容需要画；
2. 准备当前 frame / surface 等绘制目标；
3. 调用 render pipeline 的 `draw(...)`，把 `RenderNode` 树对应的命令下发到 GPU；
4. 在 `draw()` 的后半段进入 `swapBuffers(...)`，并把这一帧的 `DequeueBufferDuration` / `QueueBufferDuration` 记进 frame info。

这一步才对应“RenderThread 在画”。它吃的是主线程前面准备好的树状态和录制结果，不是重新帮主线程做一次 layout / draw。前面 Java/UI 线程负责把“该画什么”整理清楚，这里负责把它变成 GPU 和 buffer 系统可以消费的工作。

#### 第四步：`queueBuffer` 的位置与含义

RenderThread 向 GPU 提交命令后，如果本帧产出新内容，`queueBuffer` 会作为 Producer 侧的 buffer 提交点出现。它表示 buffer 已进入后续消费流程，不表示用户已经看到。

CPU 侧 `queueBuffer` 返回时，GPU 仍可能继续写入。Consumer 何时能安全读取由 acquire fence 约束；本帧是否被 SurfaceFlinger 采纳、何时 present，还要继续检查 transaction、latch、HWC 和 present fence。

在 Perfetto 上快速判断 RenderThread 这一段有没有出问题，建议按这个顺序看：

- `syncAndDrawFrame` 这一帧是不是已经明显晚了；
- RenderThread 上的绘制执行阶段是在耗 GPU / swap，还是已经卡到 buffer 相关等待；
- 这一帧对应的 `queueBuffer`、`DequeueBufferDuration`、`QueueBufferDuration` 有没有异常；
- 如果 App 侧已经按时把 buffer 交出去，就继续检查 `BufferTX - <layerName>`、latch、SurfaceFlinger actual slice 和 present timing。

### 起帧 5：持续进入下一帧调度才能形成连续帧

因为渲染是一个按帧节奏推进的循环。只要以下任何一件事还在持续，应用就还需要下一帧：

- 输入流还没结束；
- 动画还没结束；
- 还有未处理完的布局 / 重绘请求；
- 这一帧提交后，还要继续准备下一帧。

连续动画、输入或重绘请求需要继续注册下一帧工作，Choreographer 才会在后续 VSync 周期再次唤醒应用。Android 17 的 `Choreographer.scheduleFrameLocked()` 用 `mFrameScheduled` 合并同一个 pending frame 的重复请求，避免一次状态变化触发多份 VSync 申请。

## 3. 提交阶段：内容如何从 App 进入系统


如果说 MainThread 和 RenderThread 负责“把这一帧做出来”，那 `Surface`、`BufferQueue`、`Layer` 负责的就是“把这份结果送到系统能理解的位置上”。这三个词经常被混着说，需要分别看。

### 提交 1：`Surface` 是 Producer 侧的输出口

对应用来说，它最直接面对的是 `Surface` 或 `ANativeWindow` 这一类对象。RenderThread 也好，游戏引擎也好，视频解码器也好，最终都要把自己的图形结果写到某个输出目标里。这个输出目标就是 Producer 这一侧看到的接口。

### 提交 2：`BufferQueue` 负责内容周转

`BufferQueue` 负责把 Producer 和 Consumer 接起来。最经典的四个动作就是：

1. `dequeueBuffer`：Producer 取一个当前可写的 buffer；
2. Producer 往这个 buffer 里填内容；
3. `queueBuffer`：Producer 把填好的 buffer 重新挂回队列；
4. `acquireBuffer` / `releaseBuffer`：Consumer 取走它、用完它，再把它释放回去。

`dequeueBuffer` 决定本次写入哪一块内存，`queueBuffer` 把已填充的 buffer 交回队列，等待 Consumer 消费。

### 提交 3：BufferQueue 传递 buffer 引用、元数据和同步信息

`queueBuffer` 不会通过 Binder 把整帧像素复制到 SurfaceFlinger。BufferQueue 传递 buffer slot、`GraphicBuffer` 引用、acquire fence、crop、transform、dataspace、时间戳等信息；已经缓存过的 buffer 还可以只引用既有 slot 或 buffer id。

`GraphicBuffer` 背后的内存由 gralloc 分配，对 framework 来说，native handle 的内部布局是不透明的。Android 设备的常见 Linux 实现会在 handle 中携带可共享的 dma-buf fd，让 GPU、显示控制器、视频或 Camera 硬件访问同一份分配；具体 handle 字段和硬件访问方式由 gralloc 与 vendor 实现决定，不能把 dma-buf 当成 framework API 契约。

这条路径可以按四步观察：

1. Producer 通过 `dequeueBuffer` 拿到一个可写的 `GraphicBuffer`；
2. RenderThread / GPU / 解码器把结果写进这块 buffer；
3. `queueBuffer` 提交 slot、fence 和本帧元数据；首次出现或缓存失效时，还要传递可导入的 buffer handle；
4. Consumer 导入或复用该 buffer，并在 acquire fence 满足后访问内容。

工程里常说的“零拷贝”通常指这段传递没有逐层复制整帧像素，不代表端到端永远只有一块 buffer。`TextureView` 会把内容作为纹理采样进宿主窗口；离屏渲染、截图、格式转换和 SurfaceFlinger client composition 都可能分配新的输出 buffer，增加一次采样或合成。判断成本时要区分“BufferQueue 没有复制像素”和“整条显示路径没有额外合成”。

共享图形内存还需要明确读写顺序。`GraphicBuffer` / native handle 标识要访问哪份分配，fence 标识这份分配何时可读、何时可复用。两类信息缺一不可。

### 提交 4：BLAST 把 buffer 和窗口状态绑成同一笔事务

标准 App Window 中，`queueBuffer` 先把 buffer 放回应用进程内的 BufferQueue。BLAST 的 `onFrameAvailable()` 随后通过 `acquireNextBufferLocked()` 获取 `BufferItem`，调用 `Transaction::setBuffer()` 写入 buffer、acquire fence、frame number 和 release callback，再把 transaction 送到 SurfaceFlinger。需要与窗口几何同步的 transaction 可以按 frame number 合并。

这也是为什么现在看标准 App Window，不能只盯 `queueBuffer`。因为系统关心的不只“有没有新 buffer”，还包括：

- 这个 buffer 对应哪个 Layer；
- 这次窗口有没有位置、尺寸、crop、alpha、可见性变化；
- 这些变化是不是要和 buffer 一起生效。

### 提交 5：buffer 数量变化暴露生产和消费速度差

App 侧和 SF 侧都可能出现 buffer 数量或 pending 状态信号。它们位于不同队列，不能只看数值相似就当成同一个 counter。生产速度、Consumer 采纳速度、fence readiness 和最大可获取 buffer 数共同决定是否出现积压或 Producer 等待。

- 如果可用 buffer 长期很少，Producer 可能更容易卡在 `dequeueBuffer`；
- 如果 `BufferTX - <layerName>` 长期偏多，说明 SF server 已收到多笔 buffer update，但 latch 或 drop 没有及时消化；
- 如果 App 这边看起来已经 `queueBuffer` 很多次了，SF 那边却没有对应采纳，往往说明问题已经进入系统侧节奏。

这类 counter 用来定位生产与消费的节奏差，不能单独给出根因。还要结合 frame token、acquire fence、latch reason 和 SurfaceFlinger actual slice 判断。

### 提交 6：`Layer` 是系统侧的显示对象

应用提交的是 buffer 和层状态 transaction，SurfaceFlinger 按 layer 组织屏幕上的合成对象。Android 17 的 FrontEnd 先把 transaction 合入 `RequestedLayerState`，再为当前帧生成 `LayerSnapshot`；CompositionEngine 使用 snapshot 描述的可见性、几何、z-order、buffer 和效果状态准备输出。对系统来说，要回答的问题包括：

- 这个 layer 现在是不是可见；
- 它的几何关系怎样；
- 它在兄弟层里排第几；
- 它这一帧有没有新的 buffer 和新的事务一起到来；
- 最终它该不该参与本轮合成。

应用侧诊断常从 thread、slice、buffer 开始；进入 SurfaceFlinger 后，观察对象变成 layer、transaction、snapshot、output 和 fence。跨过这个边界仍只盯应用线程，会漏掉系统侧的等待与合成决策。

## 4. 显示阶段：系统如何采纳、合成并送屏


SurfaceFlinger 按显示节奏接收 transaction、更新层状态、构建本帧 snapshot，并让 CompositionEngine 为各个 display 生成输出。buffer 只是其中一种 layer 更新；窗口几何、可见性、层级、颜色空间和显示策略也会影响本轮合成。

### 显示 1：SurfaceFlinger 先接收事务和 layer 状态

App 这一侧把窗口几何、layer 属性、buffer 更新通过事务一路送过来之后，SurfaceFlinger 会先把这些变化收进来。对标准窗口来说，这一步里既可能有位置、裁剪、透明度变化，也可能只有 buffer 变化。

Perfetto 上的 transaction 相关 slice 和 `BufferTX - <layerName>` counter 可以确认服务端何时收到更新。这条 counter 专门统计 pending buffer transaction，不是所有 layer 属性 transaction 的总数，也不表示本轮合成已经完成。

Android 17 的 `Layer.h` 对这个 counter 给出了明确语义：

- 含 buffer 的 transaction 到达 server 并计入 pending 后，counter 上升；
- buffer 被 latch 或 drop 后，counter 下降；
- 长期偏高，说明到达 server 的 buffer update 没有及时 latch 或 drop，需要继续查 acquire fence、backpressure 和 SF 帧节奏；
- 长期接近 0 只能说明 server 侧没有积压。若仍 miss deadline，要再看 App 是否晚提交、FrameTimeline token 是否匹配，以及显示后段是否超时。

### 显示 2：`acquire fence` 决定 buffer 是否可读

共享 `GraphicBuffer` 只解决“访问哪份图形内存”，不解决读写先后顺序。SurfaceFlinger、RenderEngine 或 HWC 要靠 fence 判断何时可以读取。

`queueBuffer` 发生，不等于 SurfaceFlinger 这一帧就一定能把它拿来合成。因为“buffer 到了”和“buffer 已经可以安全读”是两件事，中间隔着 fence。

Producer 提交 buffer 时随附表示写入完成时机的 fence；Consumer 把它作为 acquire fence 使用。Consumer 可以在 CPU 上等待 fence signal，也可以把 fence 继续交给后续 GPU / HWC，让读取方在硬件流水线上等待。标准 HWUI 路径里它通常表示 GPU 写入完成；Camera、Video、Native Graphics 等路径还可能由解码器、Camera HAL、blitter 或其他硬件 Producer 创建。

RenderThread 发出 GPU 命令后，GPU 可能仍在写入 buffer。CPU 侧的 `queueBuffer` 只表示提交动作返回；没有 fence 约束，Consumer 可能读取到尚未完成的内容。

### 显示 3：latch 把可读 buffer 挂到本轮合成

`latch` 把某层的新 buffer 采纳为本轮合成输入。若 transaction 尚未 ready、acquire fence 不满足策略条件或该 buffer 被 backpressure 挡住，本轮会继续使用旧内容或等待后续帧处理。

Android 13+ 支持在受限条件下 latch unsignaled buffer，不必在 transaction readiness 阶段等待 acquire fence signal。

这个机制在 AOSP 文档里叫 **latch unsignaled buffer**，由 `debug.sf.auto_latch_unsignaled` 选择策略。Android 17 的 `transactionReadyBufferCheck()` 会调用 `shouldLatchUnsignaled(...)`：transaction 必须只更新一个 layer；AutoSingleLayer 模式还要求它是队列中的第一笔 transaction，并且调度器没有使用 early VSync 配置；`RequestedLayerState::isSimpleBufferUpdate()` 也必须通过。满足这些条件时，readiness 会标成 `NotReadyUnsignaled`，`Layer::fenceHasSignaled()` 允许先 latch。RenderEngine 或 HWC 读取 buffer 时仍要遵守 acquire fence。这个优化把等待位置移到更靠后的硬件边界，没有取消同步约束。

### 显示 4：合成阶段按显示节奏组织所有 layer

SurfaceFlinger 不会因为某个 App 刚刚交了 buffer，就马上单独为它合成一次。它是按自己的显示帧节奏来工作。到了这一帧，它会看：

- 哪些 layer 当前可见；
- 哪些 layer 这次有新内容；
- 哪些 layer 几何状态有变化；
- 这批 layer 最终怎样组合更合适。

这也解释了一个常见现象：应用侧很早就结束了，但最终画面还是晚了一帧——系统这一帧来不及或者不适合把它拿进去。

### 显示 5：应用侧和系统侧提前量共同决定 deadline

Android 17 的 Scheduler 以预测 present time 为目标，根据 app 与 SurfaceFlinger 各自的 `workDuration`、`readyDuration` 安排唤醒时间。旧资料常用 `app offset`、`sf offset` 描述相对硬件 VSync 的固定相位；读 Android 17 源码和 trace 时，应使用预测 present time 与工作预算来理解。

- App 的 wakeup time 要为主线程、RenderThread、GPU 写入和 buffer post 留出时间；
- SurfaceFlinger 的 wakeup time 要为 transaction flush、latch、composition strategy、必要的 GPU composition、HWC 和显示后段留出时间。

某个阶段完成得早，不保证它赶上目标 present。诊断时要把 actual timeline 与 expected timeline 对齐，确认超时发生在 App、SurfaceFlinger CPU、SurfaceFlinger GPU 还是 DisplayHAL。

### 显示 6：HWC 决定 device composition 还是 client composition

HWC 负责决定本轮各个 layer 的合成方式：**哪些能直接交给显示硬件处理（device composition），哪些必须退回给 GPU（client composition）。**

SF 与 HWC 会协商每个 layer 的 composition type。Android 17 不保证每帧都先调用独立的 `validateDisplay()`；`HWComposer::getDeviceCompositionChanges()` 会根据本轮是否已有 client composition，以及设备是否支持 expected present time 等条件判断能否 skip validate：

1. SF 设置 layer buffer、composition type、crop、transform、dataspace、blend、z-order；
2. SF / CompositionEngine 准备 composition strategy；只有 `canSkipValidate` 成立时，HWC 侧才会尝试 `presentOrValidateDisplay()`；
3. 如果 fast path 已经 present 成功，HWC 会返回 present fence，并在同一轮收集 release fences；
4. 如果 `presentOrValidateDisplay()` 返回 Validated，validate 已经在这个 HAL 调用里完成，SF 继续读取 changed composition / requests，再用 `acceptChanges()` 接受 HWC 改动；
5. 如果本轮不能 skip validate，SF 才用 `validateDisplay()` 让 HWC 评估当前 layer 集合，再读取 `getChangedCompositionTypes()` / requests 并 `acceptChanges()`；
6. 如果存在 `CLIENT` layer，RenderEngine / GPU 生成 client target；
7. `setClientTarget()` 把 client target buffer 和 acquire fence 交给 HWC；
8. `presentAndGetReleaseFences()` 收尾：如果前面还没有 present，就调用 `presentDisplay()`，再收集 per-display present fence 和 per-layer release fence。

HWC 能力与 vendor 策略通常会评估这些条件：

- 有没有透明混合；
- 有没有旋转、缩放、裁剪；
- 有没有受保护内容；
- 有没有视频、字幕、控制层同时叠加；
- 这一帧适不适合直接交给显示硬件处理。

条件合适的 layer 直接走 hardware composition；条件不合适的，SurfaceFlinger 用 GPU 把它们合成到 client target buffer，再通过 `setClientTarget()` 交回 HWC 做 present。同一组 layer 走哪条路径，每一轮都会重新判断。`presentOrValidateDisplay()` 只有在可 skip validate 时才会尝试：PresentSucceeded 分支返回 present fence；Validated 分支已经完成 validate，后面继续读取 changed composition / requests，并经过必要的 client composition / `setClientTarget()` / `presentDisplay()` 等收尾。

这也解释了一个常见现象：应用侧没明显变重，系统侧功耗和时延却突然抬起来。问题不一定是“谁突然画慢了”，也可能只是 HWC 这一轮判断：这批 layer 条件不合适，得把更多工作退回给 GPU。

FrameTimeline 的 SurfaceFlinger actual slice 从 SF 主线程开始工作延伸到 on-screen update，包含 Composer 和 DisplayHAL 等 SF 以下的显示栈时间。它比 SurfaceFlinger 主线程 CPU slice 更宽：device composition 可能让主线程阻塞在 HAL 调用里；client composition 的 GPU 工作可与 CPU 并行；DisplayHAL 还可能在 SF 已按时提交后错过目标 VSync。分析系统侧 jank 时，应结合 `SurfaceFlingerCpuDeadlineMissed`、`SurfaceFlingerGpuDeadlineMissed`、`DisplayHAL` 等分类，不要把整段 actual duration 都归因于 SF 主线程。

HWC 决策会直接改变 GPU 负载、overlay 使用、受保护内容路径和显示功耗。视频、AOD、高刷与低功耗场景都要结合这一层分析。

### 显示 7：`present fence` 定位最终送显边界

`acquire fence` 回答 buffer 何时可读，`present fence` 提供这一轮 display present 的完成时间。AOSP 把它作为 SurfaceFlinger 与 HWC 之间的 per-display、per-frame 同步对象；FrameTimeline 也用显示反馈判断 actual present。这个时间仍不等于 panel 像素完成光学响应或用户形成视觉感知。

App 已提交、SurfaceFlinger 已组织合成，都不等于这一轮 present fence 已经 signal。present fence 更接近本次显示输出完成的系统时间锚点；分析显示端延迟、高刷抖动和视频播放不稳时，它比 `queueBuffer` 提供了更靠后的时间证据。

HWC 返回的两类 fence 也要分开：

- **Present fence**（`presentDisplay()` 返回，或 `presentOrValidateDisplay()` 的 PresentSucceeded 分支返回，per-display、per-frame）：回答“**这一整轮 present 什么时候越过系统显示边界**”，是显示时序分析的关键锚点；
- **Release fence**（`getReleaseFences()`，per-layer、per-frame）：回答“**上一帧用的那块 buffer 什么时候可以被 Producer 安全复用**”。它告诉 SF / BufferQueue 把旧 buffer 回收给 App 的时机。

分析 present timing 用 present fence，分析“App 的 buffer 何时能 dequeue 回来、dequeueBuffer 为什么一直等”则看 release fence。两者都叫 fence、都从 HWC 返回，但方向相反、粒度不同，不能混着用。

SurfaceFlinger 还会使用 present fence 的反馈更新时间统计、FrameTimeline 与后续调度判断。因此它既是 trace 中的显示时间锚点，也是系统内部的 present timing 输入。

当 `queueBuffer` 和 latch 都按时，actual present 仍持续偏晚时，排查重点应移到 SurfaceFlinger composition、HWC、DisplayHAL、显示模式切换和调度预测。仅凭 present fence 不能再细分这些原因，还需要 SF slice、FrameTimeline jank type、HWC/DRM tracepoint 或厂商显示轨迹。

### 显示 8：进入 Display Driver 与 Panel

到了显示控制器和 Panel 这一层，系统关心的是**这份最终结果如何从 Android 显示栈继续进入设备显示后段**。

三个时刻要分开：

1. 应用提交 buffer；
2. SurfaceFlinger / HWC 完成这一轮系统侧准备；
3. Panel 把这一帧显示给用户。

这三个时刻经常不会重合。部分看上去像“应用卡了一帧”的问题，会定位到 HWC、DisplayHAL、driver 或 panel 侧。

Panel 还有扫描、刷新节奏、像素响应和可变刷新率策略。**系统已经准备好** 与 **用户已经看到** 之间仍有硬件显示过程，单靠 framework trace 不能覆盖全部光学延迟。

## 5. 排查阶段：把标准路径转成检查顺序

分析一帧时，要按阶段确认它走到了哪里。对初学者来说，最容易混淆的点包括：`vsync-app` 从哪里来，主线程完成了什么，`RenderThread` 和 GPU 是什么关系，`queueBuffer` 之后为什么还没显示，SurfaceFlinger 到底在等什么。

把前面的阶段压成一条检查顺序，可以这样读：

1. App 通过 `DisplayEventReceiver` 申请下一次 VSync，SurfaceFlinger Scheduler 使用 `VSyncTracker` / `VSyncDispatch` 的预测结果安排应用 wakeup，并由 EventThread connection 把事件送入 App；旧实现常用 `DispSync` 与 `app offset` 描述固定相位，不能直接套到 Android 17；
2. `Choreographer#doFrame` 在主线程按 `INPUT → ANIMATION → INSETS_ANIMATION → TRAVERSAL → COMMIT` 组织这一帧（`INSETS_ANIMATION` 在 Android 11+ 新增，落在 Animation 之后、Traversal 之前）；
3. `RenderThread` 把这一帧变成实际图形输出，并通过 `BLASTBufferQueue` / `queueBuffer` 提交出去；
4. buffer 带着 fence 进入 SurfaceFlinger，server 侧的 pending buffer 变化可以通过 `BufferTX - <layerName>` 观察；
5. SurfaceFlinger 按帧节奏决定何时 latch、何时合成，并与 HWC 协作决定最终显示方式；
6. `present fence` 和显示后段信号回答“这一帧到了哪个显示时间边界”。

按这个顺序对齐 `queueBuffer`、`BufferTX - <layerName>`、latch、`present fence` 与 FrameTimeline，可以确认本帧停在哪个阶段。


下面三组是基于 Android 17 源码整理的调用骨架，不是可编译代码，也没有展开错误处理和旁支。第一组用来确认 UI 线程从帧调度进入 HWUI 的位置。

```text
// Conceptual App UI path: Choreographer -> ViewRootImpl -> HWUI Java entrance
ViewRootImpl.scheduleTraversals()
    if (!mTraversalScheduled) {
        mChoreographer.postVsyncCallback(CALLBACK_TRAVERSAL, mTraversalCallback)
        notifyRendererOfFramePending()
    }

Choreographer.scheduleFrameLocked(now)
    if (!mFrameScheduled) {
        scheduleVsyncLocked()
    }

Choreographer.doFrame(frameTimeNanos, frame, vsyncEventData)
    doCallbacks(CALLBACK_INPUT)
    doCallbacks(CALLBACK_ANIMATION)
    doCallbacks(CALLBACK_INSETS_ANIMATION)
    doCallbacks(CALLBACK_TRAVERSAL)
        TraversalCallback.onVsync(frameData)
            ViewRootImpl.doTraversal(frameData.getFrameTimeNanos())
    doCallbacks(CALLBACK_COMMIT)

ViewRootImpl.doTraversal(frameTimeNanos)
    performTraversals(frameTimeNanos)
        performMeasure()
        performLayout()
        performDraw()
            ThreadedRenderer.draw(view, attachInfo, callbacks)
                HardwareRenderer.syncAndDrawFrame(frameInfo)
```

这组骨架把 `doFrame()` 的五段 callback 与 `syncAndDrawFrame()` 放在同一条 UI 线程栈上。`syncAndDrawFrame()` 是交给 RenderThread 的入口，不是 present 完成点。

第二组只保留 RenderThread 的状态同步、绘制与 buffer 提交，用来区分 UI 线程等待和 GPU 异步执行。

```text
// Conceptual HWUI RenderThread path: sync RenderNode tree -> draw -> submit buffer
RenderProxy::syncAndDrawFrame()
    DrawFrameTask::drawFrame()
        CanvasContext::prepareTree()
        CanvasContext::draw()
            // Skia OpenGL / Vulkan backend records and submits GPU work.
            // CPU submission can return before the buffer is safe to read.
            swapBuffers_or_queueBuffer(buffer, producerCompletionFence)
```

`CanvasContext::draw()` 会记录 `DequeueBufferDuration` 与 `QueueBufferDuration`。CPU 完成 command submission 或 `queueBuffer` 后，GPU 仍可能通过 producer completion fence 表示写入尚未完成。

第三组从 BLAST 的 buffer transaction 接到 SurfaceFlinger 与 HWC，用来区分 transaction readiness、latch 和 present。

```text
// Conceptual BLAST + SurfaceFlinger + HWC path: queue, transaction, latch, fences
Surface::queueBuffer(buffer, producerCompletionFence)
    BufferQueueProducer::queueBuffer(slot, QueueBufferInput{fence, ...})
    BLASTBufferQueue::onFrameAvailable(BufferItem)
        BLASTBufferQueue::acquireNextBufferLocked()
            Transaction::setBuffer(surfaceControl, buffer, acquireFence, frameNumber, ...)
            Transaction::apply()

SurfaceFlinger::setTransactionState()
    TransactionHandler::queueTransaction()

SurfaceFlinger::updateLayerSnapshots()
    TransactionHandler::collectTransactions()
    TransactionHandler::flushTransactions()
        transactionReadyBufferCheck()
        if (acquireFence is not signaled)
            wait_or_mark_NotReadyUnsignaled_when_latch_unsignaled_is_allowed()
    LayerLifecycleManager::applyTransactions()
    LayerSnapshotBuilder::update()
    Layer::latchBufferImpl()

SurfaceFlinger::composite()
    setLayerBuffer_and_layer_state()
    HWComposer::getDeviceCompositionChanges()
        if can_skip_validate:
            HWC2::Display::presentOrValidate()
            if PresentSucceeded:
                collect_present_fence_and_release_fences()
            else: // Validated; validate already happened in presentOrValidate
                getChangedCompositionTypes()
                acceptChanges()
        else:
            HWC2::Display::validate() / ComposerHal::validateDisplay()
            getChangedCompositionTypes()
            acceptChanges()
    if (compositionType == CLIENT)
        RenderEngine::drawLayers(...)
        HWComposer::setClientTarget(clientTarget, clientTargetAcquireFence)
    HWComposer::presentAndGetReleaseFences()
        if not_already_presented:
            HWC2::Display::present()
        HWC2::Display::getReleaseFences()
```

App 提交 buffer 只说明内容进入图形队列；`BufferTX - <layerName>` 记录 SF server 侧 pending buffer update；`acquire fence` 约束读取时机；`release fence` 约束旧 buffer 的复用时机；`present fence` 给出 display present 的时间反馈。这五个信号不能互相替代。

## 6. 源码入口：优先跟读哪里


这些入口覆盖 Java UI、HWUI、BLAST、SurfaceFlinger FrontEnd、CompositionEngine 和 HWC。链接全部固定到 Android 17 / API 37 的 `android-17.0.0_r1` tag。

- [`frameworks/base/core/java/android/view/Choreographer.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/core/java/android/view/Choreographer.java)
  - 看 `scheduleFrameLocked()`、`scheduleVsyncLocked()`、`doFrame()`，确认 VSync 申请、`mFrameScheduled` 合并和五类 callback 顺序。
- [`frameworks/base/core/java/android/view/ViewRootImpl.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/core/java/android/view/ViewRootImpl.java)
  - 重点看 `scheduleTraversals()`、`performTraversals(long frameTimeNanos)`、`performDraw()`、窗口 relayout 相关主线。
- [`frameworks/base/graphics/java/android/graphics/HardwareRenderer.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/graphics/java/android/graphics/HardwareRenderer.java) 与 [`frameworks/base/core/java/android/view/ThreadedRenderer.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/core/java/android/view/ThreadedRenderer.java)
  - Java 层进入 HWUI 的入口，看 `draw()` 如何更新 root `RenderNode` 再通过 `syncAndDrawFrame()` 下发。
- [`frameworks/base/libs/hwui/renderthread/RenderProxy.cpp`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/libs/hwui/renderthread/RenderProxy.cpp)、[`DrawFrameTask.cpp`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/libs/hwui/renderthread/DrawFrameTask.cpp)、[`CanvasContext.cpp`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/libs/hwui/renderthread/CanvasContext.cpp)
  - 这一组能把 `syncAndDrawFrame`、RenderThread、GPU 提交这几步接起来；`CanvasContext::prepareTree()` 对应第一步的状态同步，`CanvasContext::draw()` 对应第三步的绘制执行与 `swapBuffers`。
- [`frameworks/native/libs/gui/BLASTBufferQueue.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/libs/gui/BLASTBufferQueue.cpp)
  - 对照 `onFrameAvailable()`、`acquireNextBufferLocked()`、`Transaction::setBuffer()` 与按 frame number 合并 transaction 的逻辑。
- [`frameworks/native/services/surfaceflinger/FrontEnd/`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/services/surfaceflinger/FrontEnd/)、[`Layer.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/services/surfaceflinger/Layer.cpp)
  - FrontEnd 的 `RequestedLayerState`、`LayerLifecycleManager`、`LayerSnapshotBuilder` 解释 transaction 如何变成本帧 snapshot；`Layer.cpp` 可对照 `BufferTX - <layerName>`、latch 与 release callback。
- [`frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/services/surfaceflinger/SurfaceFlinger.cpp)、[`CompositionEngine/`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/services/surfaceflinger/CompositionEngine/)、[`Scheduler/FrameTimeline.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/services/surfaceflinger/Scheduler/FrameTimeline.cpp)
  - 对照 `transactionReadyBufferCheck()`、`shouldLatchUnsignaled()`、composition、present feedback，以及 FrameTimeline 的 `SurfaceFrame` / `DisplayFrame` 打点位置。
- [`frameworks/native/services/surfaceflinger/DisplayHardware/HWComposer.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/services/surfaceflinger/DisplayHardware/HWComposer.cpp)
  - 对照 `getDeviceCompositionChanges()` 中的 skip-validate 条件，以及 `setClientTarget()`、`presentOrValidate()`、`getChangedCompositionTypes()`、`acceptChanges()`、`presentAndGetReleaseFences()`。

S01 没有引用 kernel 函数。后续文章需要进入 dma-buf、sync_file、DRM/KMS 或调度器实现时，源码链接统一固定到 [`kernel/common android17-6.18-2026-06_r6`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6)。

固定 tag 源码之外，还可以看下面几篇滚动文档。它们用于补充概念，正文结论仍以 Android 17 的固定源码锚点为准：

- [SurfaceFlinger and WindowManager](https://source.android.com/docs/core/graphics/surfaceflinger-windowmanager)：确认 SurfaceFlinger 如何接收 buffer、metadata，以及只在显示刷新间隔采纳新 buffer 的边界。
- [Synchronization framework](https://source.android.com/docs/core/graphics/sync)：确认 acquire / release / present fence 的方向、粒度和 HWC 调用关系。
- [Implement Hardware Composer HAL](https://source.android.com/docs/core/graphics/implement-hwc)：确认 HWC 为什么能减少 GPU composition，以及 protected video、format、blend 等能力约束。
- [Unsignaled buffer latching with AutoSingleLayer](https://source.android.com/docs/core/graphics/unsignaled-buffer-latch)：确认 Android 13+ latch unsignaled buffer 的默认模式、系统属性和适用边界。
- [Android Jank detection with FrameTimeline](https://perfetto.dev/docs/data-sources/frametimeline)：确认 FrameTimeline 里的 App / SurfaceFlinger actual slice、Layer Name、GPU Composition、Jank Type 等观察口径。
- [PerfettoSQL standard library](https://perfetto.dev/docs/analysis/stdlib-docs)：确认 `actual_frame_timeline_slice`、`expected_frame_timeline_slice` 的字段语义。


## 7. 版本演进：Android 12 到 Android 17

这条公共显示主线从 Android 12 起讨论。Android 12 已经具备 BLAST、FrameTimeline、现代 SurfaceControl transaction 和 HWC2/HWC3 语义，足以覆盖仍有工程价值的设备。版本差异应落到具体对象和观测方法上，不能把系统大版本号直接当成性能结论。

| 平台 | 与公共显示主线相关的变化 | 对 Perfetto 判读的影响 |
|---|---|---|
| Android 12 / API 31 | BLAST 已成为 App Window / SurfaceView 的现代 buffer-transaction 基线；FrameTimeline 从 Android 12 起可用 | 可以用 app / SF expected、actual timeline 和 token 对齐标准窗口帧；独立 Surface 仍需额外 layer 与 BufferQueue 证据 |
| Android 13 / API 33 | `AutoSingleLayer` 模式下的 latch unsignaled buffer 成为默认策略 | “acquire fence 未 signal”不再必然表示 transaction readiness 阶段完全不能 latch；读取 buffer 前的同步依赖仍然存在 |
| Android 14 / API 34 | 公共的 Choreographer→HWUI→BLAST→SF→HWC 骨架没有需要重画的结构变化；SurfaceView 分支增加任意 alpha 与公开 lifecycle 策略 | 标准窗口仍按公共主线分析；涉及独立 Surface 的透明度和销毁/保留行为时，要把平台版本纳入判断 |
| Android 15 / API 35 | Window 与 SurfaceView 增加 desired HDR headroom 能力，显示策略可以接收更明确的 HDR/SDR 比例请求 | headroom 是期望值，不是 buffer 完成或显示亮度保证；HDR 问题还要结合 dataspace、bit depth、display 与 HWC 能力 |
| Android 16 / API 36 | 公共骨架继续沿用；SurfaceView 增加整数 `compositionOrder`，独立 layer 的相对层级表达更细 | 多 layer 页面需要记录完整 Z-order；标准 App Window 的 Producer/Consumer 边界未因此改变 |
| Android 17 / API 37 | 本系列当前锚点使用 FrontEnd `RequestedLayerState` / `LayerSnapshot`、预测 present time 与 work budget、现行 BLAST/HWC 流程；SurfaceView 另增加 blur region | 源码调用名按 Android 17 解释。看到旧资料中的 `DispSync`、固定 app/sf offset 或逐个旧 `Layer` latch 模型时，需要换回当前对象 |

### Android 12：现代 trace 基线

Android 12 的两个关键点是 BLAST 和 FrameTimeline。

BLAST 在应用进程侧把 BufferQueue 的新 buffer 组织成 `SurfaceComposerClient::Transaction`，使 buffer、frame number 与相关 layer 状态可以沿统一 transaction 边界进入 SurfaceFlinger。它没有把 Producer、Consumer 合成一个线程，也没有取消 acquire/release fence。

FrameTimeline 提供 App `SurfaceFrame` 与 SurfaceFlinger `DisplayFrame` 的 expected/actual 时间线，jank 的定义围绕预测 present time 展开。它适合标准 App Window；Perfetto 官方文档同时声明 SurfaceView 主体当前不受完整支持，所以总览中的 layer、BufferQueue、fence 和 HWC 证据仍不可省略。

### Android 13：latch unsignaled 改变等待位置

Android 13 起，官方文档把 `AutoSingleLayer` 作为 latch unsignaled buffer 的默认模式。满足单 layer、简单 buffer update、队列顺序和调度条件时，SurfaceFlinger 可以先采纳 buffer 状态，把 fence wait 推迟到靠近 RenderEngine 或 HWC 读取的位置。

这个变化影响 trace 解释：transaction 被 latch 与硬件写入完成是两个时间点。若只看到 latch 已发生就结束调查，会漏掉后面的 acquire fence wait；若只看到 fence 尚未 signal 就断言 SF 绝不可能 latch，也会与 Android 13 之后的实现不符。

### Android 14：公共骨架稳定，分支能力变化

对标准窗口的 Choreographer、HWUI、BLAST、SurfaceFlinger、HWC 主线，Android 14 没有引入需要改画总图的公开结构替换。这个版本更值得关注的是分支语义：SurfaceView 支持任意 alpha，并公开 visibility/attachment 两类 Surface 生命周期策略。

因此，同一个 trace 里公共 present 路径仍按本文分析；遇到 SurfaceView 半透明、前后台恢复或独立 Surface 重建问题时，再进入对应分支的版本规则。版本演进的目的在于缩小证据范围，不是让每个版本都强行对应一套新管线。

### Android 15：HDR headroom 进入独立请求

API 35 允许 Window 和 SurfaceView 表达 desired HDR headroom。这个比例描述期望的 HDR 白点相对 SDR 白点范围，系统仍会结合面板、环境、bit depth 和显示策略决定能否满足。

Perfetto 中即使看到请求已经提交，也不能据此判断最终 luminance、tone mapping 或 composition type。还要检查 buffer dataspace/HDR metadata、目标 display 状态以及 HWC/RenderEngine 的实际合成路径。

### Android 16：独立 layer 层级表达扩展

API 36 的 `SurfaceView.setCompositionOrder()` 用整数表达 SurfaceView 位于宿主上方或下方，以及 peer 之间的相对次序。它改变的是独立 layer 的组织能力，不改变标准 App Window 经过 HWUI、BLAST、SurfaceFlinger 和 HWC 的公共骨架。

分析多 Surface 页面时，应记录 layer parent、relative layer 和 composition order。只按 layer name 排序，无法证明最终 Z-order。

### Android 17：本文的当前实现

Android 17 的 SurfaceFlinger FrontEnd 以 `RequestedLayerState`、`LayerLifecycleManager` 和 `LayerSnapshotBuilder` 管理 transaction 状态与当前帧 snapshot；Scheduler 以预测 present time、`workDuration`、`readyDuration` 计算 App 与 SF 的工作窗口；HWC 路径允许在条件满足时用 `presentOrValidateDisplay()` 合并 validate/present 往返。

这些名字是本文源码 Review 的锚点，不代表每项机制都首次出现于 Android 17。版本首引必须回到对应 tag 或 API 文档确认，不能因为

GENERATED FILE - DO NOT EDIT.
Source: docs/rendering_pipelines/S02_aosp_standard_type.md
Source SHA-256: ea3bcea43c3548a97e11c2f062e93b1e8d1b0954cd9b207287d2abed903e1153

# Android Perfetto 系列 - App 出图类型 - AOSP 标准类型

这篇处理的是 **AOSP 标准 HWUI 页面在一帧里的完整出图过程**：页面状态由主线程整理，RenderThread 生成窗口 buffer，SurfaceFlinger、HWC 和显示设备完成合成与 present。

标准页面只有一个承载主体内容的 App Window surface，没有额外的独立内容 layer 或引擎帧循环。它适合用来建立 Perfetto 排查基线。读完这篇应当能回答两件事：

- 为什么它可以作为后续所有分叉类型的对照基线；
- 如何用调度、FrameTimeline、BufferQueue、SurfaceFlinger 和 HWC 证据判断瓶颈位置。

`SurfaceView`、`TextureView`、`WebView`、Flutter、Camera 和 Video 会改变 Producer、surface 或 layer 的组织方式。标准页面先把 `vsync-app`、`doFrame`、RenderThread、BLASTBufferQueue、SurfaceFlinger、HWC 与 present timing 放到同一条时间轴上，后续才能判断分叉发生在哪里。

<!--more-->

## 阅读导航

### 本文目录

- 阅读说明
- 1. 一帧完整流程：标准 HWUI 页面怎样到屏幕
- 显示链路图：标准 HWUI App Window
- 关键节点说明
- 2. 类型判定：什么 trace 算 AOSP 标准页面
- 3. 系列角色：为什么它是所有分叉的对照组
- 4. 普通列表滑动的一帧怎样经过这些节点
- 5. 第一轮排查：标准页面先看四个关口
- 6. Compose 分支：标准 App Window 中哪些工作变了
- 7. 为什么标准链适合做性能基线
- 8. 系统可调节点：能从 trace 证明什么
- 9. 源码入口：优先跟读哪里
- 10. 版本演进：Android 12 到 Android 17
- 11. Perfetto 证据链：按标准路径排查
- 12. 类型边界：和相邻类型分开
- 13. 最终判定：哪些信号足以归类
- 14. 判读边界
- 总结

### 系列文章目录

1. [Android Perfetto 系列 - App 出图类型 - 总览与识别方法](S01_rendering_types_overview.md)
2. [Android Perfetto 系列 - App 出图类型 - AOSP 标准类型](S02_aosp_standard_type.md)
3. [Android Perfetto 系列 - App 出图类型 - SurfaceView 类型](S03_surfaceview_type.md)
4. [Android Perfetto 系列 - App 出图类型 - TextureView 类型](S04_textureview_type.md)
5. [Android Perfetto 系列 - App 出图类型 - 混合出图类型](S05_mixed_rendering_type.md)
6. [Android Perfetto 系列 - App 出图类型 - 多窗口类型](S06_multi_window_type.md)
7. [Android Perfetto 系列 - App 出图类型 - Software / 离屏类型](S07_software_offscreen_type.md)
8. [Android Perfetto 系列 - App 出图类型 - Native Graphics 类型](S08_native_graphics_type.md)
9. [Android Perfetto 系列 - App 出图类型 - WebView 类型](S09_webview_type.md)
10. [Android Perfetto 系列 - App 出图类型 - Flutter 类型](S10_flutter_type.md)
11. [Android Perfetto 系列 - App 出图类型 - Camera 类型](S11_camera_type.md)
12. [Android Perfetto 系列 - App 出图类型 - Video Overlay / HWC 类型](S12_video_overlay_hwc_type.md)
13. [Android Perfetto 系列 - App 出图类型 - Game 类型](S13_game_type.md)
14. [Android Perfetto 系列 - App 出图类型 - React Native 类型](S14_react_native_type.md)

## 阅读说明

标准页面的判断问题很直接：主体内容是不是仍然由普通 View / Compose / HWUI 生产，并通过当前 App Window 这一层提交到系统。

平台源码固定到 Android 17 / API 37 的 `android-17.0.0_r1`，kernel 源码固定到 `android17-6.18-2026-06_r6`。framework、HWUI、SurfaceFlinger 与 HWC 的调用名按 platform tag 核查；cpuset、uclamp、schedutil 和 cpufreq 只按指定 kernel tag 说明可观察机制。Jetpack Compose 独立发布，不属于 platform tag，相关段落以当前官方文档为依据并明确版本边界。

类型判断围绕一条路径展开：`vsync-app` → `Choreographer#doFrame` → RenderThread → BLASTBufferQueue / `queueBuffer` → SurfaceFlinger → HWC → present timing。主体内容完整经过这条路径时按标准 HWUI 页面分析；出现独立 Producer、独立 layer 或其他引擎帧循环时，再切换到相应类型。

## 1. 一帧完整流程：标准 HWUI 页面怎样到屏幕


标准 HWUI 页面的一帧会经过下面 12 个阶段。这里描述的是主体 App Window；壁纸、状态栏、导航栏等系统 layer 仍会同时参与显示合成。

1. 页面因为输入、动画、`invalidate()`、`requestLayout()`、Insets 或窗口变化进入下一帧调度；Android 17 的 `ViewRootImpl.scheduleTraversals()` 注册 traversal VSync callback，`Choreographer` 用 `mFrameScheduled` 合并同一个 pending frame 的重复申请。
2. `vsync-app` 到来后，主线程进入 `Choreographer#doFrame()`，按 `INPUT → ANIMATION → INSETS_ANIMATION → TRAVERSAL → COMMIT` 处理这一帧。
3. `Traversal` 根据本帧脏标记决定是否执行 measure、layout 和 draw；硬件加速路径在 `performDraw()` 中通过 `ThreadedRenderer.draw()` 更新 RenderNode / DisplayList，并进入 UI 线程到 RenderThread 的同步边界。
4. UI 线程通过 `HardwareRenderer.syncAndDrawFrame()` / native `RenderProxy::syncAndDrawFrame()` 把 `DrawFrameTask` 投到 RenderThread；RenderThread 随后执行 `syncFrameState()`，同步主线程提交的树状态，并准备这一帧的 Skia / GPU 工作。
5. RenderThread 通过 `Surface` 从当前 App Window 的 BLAST BufferQueue Producer dequeue buffer；没有满足约束的 free slot，或返回 slot 的 release fence 尚未满足时，这一步可能等待。
6. RenderThread 通过 Skia pipeline 生成并提交 GPU 命令；随 buffer 一起提交的 producer completion fence 会在 Consumer 侧作为 acquire fence，表示 Consumer 何时可以安全读取这块 buffer，`queueBuffer()` 返回时 GPU 工作可能仍未完成。
7. RenderThread `queueBuffer()`，把本帧 buffer、producer completion fence 和帧号交给 `BLASTBufferQueue`。
8. App 进程内的 BLAST Consumer acquire `BufferItem`，调用 `Transaction::setBuffer()` 并 `apply()`。SurfaceFlinger server 将 buffer transaction 计入 pending 后，`BufferTX - <layerName>` counter 加一。
9. SurfaceFlinger 在 `vsync-sf` 节奏下 flush transaction。Android 17 FrontEnd 把更新合入 `RequestedLayerState`、构建 `LayerSnapshot`，再对目标 App Window layer latch；transaction readiness 和后续读取都要遵守 acquire fence，符合条件时允许 latch unsignaled buffer。
10. SurfaceFlinger 把本轮所有可见 layer 交给 HWC 做 composition strategy 协商：如果本轮可以 skip validate，先尝试 `presentOrValidateDisplay()`；PresentSucceeded 表示组合 HAL 调用走了 present 分支并返回 present / release fences，不表示 panel 已经显示；Validated 表示 validate 已在这次 HAL 调用里完成，后续继续 `getChangedCompositionTypes()` / requests / `acceptChanges()`；只有不能 skip validate 时，才先走 `validateDisplay()` slow path。
11. 如果存在 CLIENT layer，SurfaceFlinger / RenderEngine 先消费 layer 输入 fence 并生成 client target，再通过 `setClientTarget()` 把 client target 及其 output acquire fence 交给 HWC；随后用 `presentAndGetReleaseFences()` 收尾，如果前面尚未 present，则调用 `presentDisplay()`。
12. HWC 返回 per-display present fence 和 per-layer release fence；SurfaceFlinger 还会按 client/device composition 合并或替换 release 信息，再通过 release callback / channel 回传 Producer。Present fence 是显示栈时间锚点，不等于 panel 完成光学响应。

Perfetto 中先确认主体内容是否经过这 12 个阶段。独立 Producer、SurfaceTexture 采样、引擎帧循环、Camera HAL 或视频解码器出现后，线程名相似也不能继续套用标准页面结论。

### 显示链路图：标准 HWUI App Window

下面这张图完整画出普通 View / Compose 页面的标准 HWUI 路径。`⓪` 表示进入帧调度前的状态变化，①–⑫ 表示从 App VSync wakeup 到 present feedback 的固定观察节点。

```mermaid
sequenceDiagram
    participant MT as App MainThread
    participant RT as App RenderThread
    participant BBQ as BLASTBufferQueue
    participant GPU as App GPU queue
    participant SF as SurfaceFlinger FrontEnd / CompositionEngine
    participant HWC as HWComposer / Composer HAL
    participant DD as Display driver

    MT->>MT: ⓪ invalidate / requestLayout / animation<br/>scheduleTraversals
    SF->>MT: ① vsync-app（预测 present time 反推 wakeup）
    MT->>MT: ② Choreographer#doFrame<br/>INPUT → ANIMATION → INSETS_ANIMATION → TRAVERSAL → COMMIT
    MT->>RT: ③ syncAndDrawFrame（提交 RenderNode 树状态）
    RT->>BBQ: ④ dequeueBuffer（可能等 release fence / free slot）
    RT->>GPU: ⑤ Skia / GPU submit
    RT->>BBQ: ⑥ queueBuffer（buffer + producer completion fence）
    BBQ->>SF: ⑥' Transaction::setBuffer/apply（SF server 侧 BufferTX - layerName +1）
    DD-->>SF: ⑦ HW VSync sample / mode timing<br/>vsync-sf scheduler wakeup
    SF->>SF: ⑧ 更新 RequestedLayerState / LayerSnapshot<br/>选择 App Window buffer 并检查 acquire fence
    SF->>HWC: ⑨ 提交可见 layer 集合与 buffer fence
    alt 允许 skip validate
        SF->>HWC: presentOrValidateDisplay
        HWC-->>SF: PresentSucceeded（已保存 fences）或 Validated
    else 普通 validate
        SF->>HWC: validateDisplay
        HWC-->>SF: changed composition types / requests
    end
    opt validate / Validated 返回状态调整
        SF->>HWC: acceptChanges
    end
    opt 需要 CLIENT composition
        SF->>GPU: ⑩ RenderEngine 生成 client target
        SF->>HWC: setClientTarget（client target acquire fence）
    end
    opt 当前轮尚未 present
        SF->>HWC: ⑪ presentDisplay
        HWC-->>SF: present fence fd + layer release fence fds
    end
    HWC->>DD: 提交 display frame
    DD-->>SF: ⑫ present fence 后续异步 signal
    SF-->>BBQ: release fence fd（release callback / release channel）
    BBQ-->>RT: 下一次 dequeueBuffer 可见；signal 后旧 buffer 可复用
```

### 关键节点说明

- **⓪ 调度前奏**：`invalidate()`、`requestLayout()`、动画或 Insets 变化只表示后续帧有工作。Android 17 的 `scheduleTraversals()` 注册 traversal VSync callback，`mFrameScheduled` 避免重复申请同一个 pending frame。
- **①–③ 主线程准备**：`vsync-app` 唤醒 App 后，MainThread 处理 Input / Animation / Insets Animation / Traversal / Commit，再通过 `syncAndDrawFrame()` 同步本帧 RenderNode 树状态。
- **④–⑥' App Window buffer 提交**：RenderThread 通过当前窗口的 BLAST BufferQueue Producer 执行 `dequeueBuffer()` / `queueBuffer()`；`BufferTX - <layerName>` 在 SF server 计入 pending buffer transaction 后变化，时间点晚于 App 侧 `queueBuffer()` 返回。
- **⑦–⑨ 系统采纳和 HWC 策略**：SurfaceFlinger 在 `vsync-sf` 节奏下 latch App Window layer；只有可 skip validate 时才尝试 `presentOrValidateDisplay()`。PresentSucceeded 表示 HAL 调用已走 present 分支，Validated 后继续读取 changed composition / requests 并 `acceptChanges()`。
- **⑩–⑫ fence 与 present**：device composition 时 layer acquire fence 交给 HWC；client composition 时 RenderEngine 消费 layer 输入 fence，`setClientTarget()` 附带 client target 的 acquire fence。Present fence 提供显示栈的 present 时间反馈；release fence 经 SF 回传后约束旧 buffer 的复用时机。

## 2. 类型判定：什么 trace 算 AOSP 标准页面

如果页面主体来自普通 View 或 Compose，并由当前 App Window 的 HWUI surface 提交，没有承载主体内容的独立 Surface、浏览器渲染管线、跨平台引擎帧循环、Camera HAL 或视频解码器 Producer，就属于本文的 **AOSP 标准类型**。

最常见的例子包括：

- 普通列表页、详情页、设置页；
- 以 RecyclerView、ConstraintLayout、`ComposeView` 等标准 UI 为主的页面；
- 没有独立视频 Surface、没有地图 / 相机预览 / 浏览器主体的常规业务页面。

这种类型不一定轻，也不等于不会卡。它只是说明：**这张页面的主体内容，还完整走在标准 HWUI 窗口主线上。**

## 3. 系列角色：为什么它是所有分叉的对照组

不同出图类型的差别可以落到同一个问题：

> **它是从标准 HWUI 窗口主线的哪一步开始不一样的？**

标准类型提供一条没有额外内容 Producer 的对照路径：

- `vsync-app` 还是按主线程帧节奏往前发；
- `Choreographer#doFrame` 还是按 `INPUT → ANIMATION → INSETS_ANIMATION → TRAVERSAL → COMMIT` 组织这一帧（`INSETS_ANIMATION` 在 Animation 之后、Traversal 之前）；
- 结果还是通过当前窗口的 `RenderThread`、`BLASTBufferQueue`、`queueBuffer` 往后交；
- SurfaceFlinger 看到的重点对象，还是当前 App Window 对应的 layer；
- HWC / `present fence` 这一侧也还是标准窗口的收尾语义。

所以它最适合作为对照。后续看到：

- `SurfaceView` 会新增独立 BufferQueue 和 layer，内容不再写入宿主 App Window buffer；
- `TextureView` 使用 SurfaceTexture 接收外部 buffer，再由宿主 HWUI 采样进 App Window；
- WebView / Flutter 由 Chromium 或 Flutter Engine 组织内容生产，Android 宿主还可能选择 App Window、SurfaceView、TextureView 或额外 overlay；
- Camera / Video 的 Producer 来自 HAL 或解码器，并可能使用独立 layer、sideband 或受保护显示路径。

标准页面就是 Android App 最常见、最完整、最容易对照的一条出图路径。

## 4. 普通列表滑动的一帧怎样经过这些节点

以手指拖动 RecyclerView 为例，主线程和显示系统会依次处理这些工作：

1. `ACTION_MOVE` 到达应用后，普通输入事件通过 InputChannel 异步处理；同一 VSync 周期内积累的 batched motion event 在 Choreographer Input callback 中消费和重采样。滚动容器根据最新触点更新偏移并请求 redraw，必要时还会触发布局。
2. `Choreographer#doFrame` 继续执行 Animation、Insets Animation 与 Traversal。RecyclerView 只重绘可复用 DisplayList，还是重新 bind / measure / layout item，取决于本帧滚动范围、item 状态和 layout request，不能从“列表在动”推断 Traversal 成本固定。
3. `ThreadedRenderer.draw()` 更新 root RenderNode 后进入 `syncAndDrawFrame()`。RenderThread 准备树、取得 App Window buffer、提交 Skia / GPU 工作并 `queueBuffer()`；App actual SurfaceFrame 的结束位置取 `max(gpu completion, buffer post)`，因此 UI 线程返回不等于 App frame 已完成。
4. BLAST 把 buffer 变成 transaction。`BufferTX - <layerName>` 增加后，SurfaceFlinger 才有对应的 pending buffer update；latch 时 counter 下降，本轮 display composition 才可能采用新列表画面。
5. HWC 为所有可见 layer 决定 composition type。Present fence 和 SF DisplayFrame 给出显示栈的 present timing；panel 扫描、像素响应和触摸到光子的完整延迟还需要 driver trace 或外部高速相机等证据。

同一段滑动可能在 UI、RenderThread、buffer backpressure 或 display 侧超时。按这五步对齐证据，比只找最长 slice 更容易区分根因。

## 5. 第一轮排查：标准页面先看四个关口

标准页面没有额外主体 Producer，排查时可以沿 App Window 的单条生产路径逐段排除。

### 关口 1：`doFrame` 中哪一段增加了成本

查看 UI 线程本帧执行了哪些 callback：

- Input 是否出现批量输入消费或业务回调耗时；
- Animation 是否持续超出本帧预算；
- Traversal 是否触发大范围 measure、layout 或 DisplayList 重录；
- Traversal 末尾的 `syncAndDrawFrame()` 是否在等待 RenderThread 完成状态同步；它位于 `CALLBACK_TRAVERSAL` 执行栈内，不是独立 callback 类型。

下面的调用骨架用于定位 `ViewRootImpl.scheduleTraversals()` 到 HWUI 入口。它是从 Android 17 源码抽出的结构示意，不是可编译 Java；条件分支和错误处理已省略。

```text
// Android 17 UI-thread call skeleton
ViewRootImpl.scheduleTraversals()
    if (!mTraversalScheduled) {
        mChoreographer.postVsyncCallback(
            Choreographer.CALLBACK_TRAVERSAL, mTraversalCallback)
        notifyRendererOfFramePending()
    }

Choreographer.scheduleFrameLocked(now)
    if (!mFrameScheduled) {
        scheduleVsyncLocked()
    }

Choreographer.doFrame(frameTimeNanos, frame, vsyncEventData)
    doCallbacks(CALLBACK_INPUT)
    doCallbacks(CALLBACK_ANIMATION)
    doCallbacks(CALLBACK_INSETS_ANIMATION)
    doCallbacks(CALLBACK_TRAVERSAL)
        TraversalCallback.onVsync(frameData)
            ViewRootImpl.doTraversal(frameData.getFrameTimeNanos())
    doCallbacks(CALLBACK_COMMIT)

ViewRootImpl.performTraversals(frameTimeNanos)
    // The real implementation conditionally calls performMeasure(),
    // 根据当前状态决定是否执行 performLayout() 与 performDraw()。
    performDraw()
        ThreadedRenderer.draw(view, attachInfo, callbacks)
            syncAndDrawFrame(frameInfo)
```

这条栈能证明主体窗口由 Choreographer 和 `ViewRootImpl` 驱动。measure、layout、draw 是否执行仍由本帧状态决定，不能把三者视为每帧固定成本。

### 关口 2：`RenderThread` 在执行还是等待

RenderThread slice 变长可能来自不同原因：

- `dequeueBuffer` 是否在等待可用 slot；
- CPU command submission 或 GPU 工作是否超出预算；
- buffer 已提交但系统没有及时采纳。

`syncAndDrawFrame()` 往后先把任务投到 RenderThread，并让 UI 线程等 RenderThread 完成本帧状态同步，不能直接当成“GPU 开画”标记。

下面的结构示意用于区分 UI 线程等待、RenderThread 执行和 buffer swap。它不是可编译 C++，省略了 frame callback、skip frame、fence wait 与错误处理。

```text
// Android 17 HWUI call skeleton
android_view_ThreadedRenderer_syncAndDrawFrame(...)
    RenderProxy::syncAndDrawFrame()
        DrawFrameTask::drawFrame()
            postAndWait()

// RenderThread side
DrawFrameTask::run()
    canUnblockUiThread = syncFrameState()
        CanvasContext::prepareTree()
    if (canUnblockUiThread)
        unblockUiThread()
    CanvasContext::draw()
        mRenderPipeline->getFrame()       // dequeueBuffer / acquire back buffer
        mRenderPipeline->draw(frame, ...)
        mRenderPipeline->swapBuffers(...) // queueBuffer with producer completion fence
    if (!canUnblockUiThread)
        unblockUiThread()
```

`postAndWait()` 会让 UI 线程等待 RenderThread；`syncFrameState()` 返回后是否提前 `unblockUiThread()` 取决于本帧状态。GPU 完成时间还要结合 GPU slice 或 fence，不能由 `DrawFrame` 的 CPU duration 直接推断。

#### `dequeueBuffer` 为什么会等：slot、BLAST 与 SF pending 要分层看

标准 App Window 下，RenderThread 通过 `Surface` 使用 App 进程内的 BLAST BufferQueue Producer。BLAST Consumer acquire slot 后，通过 `SurfaceControl.Transaction` 把 buffer update 送到 SF；SF 侧表现为 `BufferTX - <layerName>`、pending、latch、present / release 这一组信号。

BufferQueue 的主状态可以这样读：

| 状态 | 谁持有 | 含义 |
|------|--------|------|
| FREE | BufferQueue | 空闲，可被 Producer dequeue；仍可能带着上一轮 release fence |
| DEQUEUED | RenderThread / Producer | Producer 已取出，准备写入或正在写入 |
| QUEUED | BufferQueue / BLAST consumer | Producer 已提交 buffer，等待 Consumer acquire；内容可读 fence 可能尚未 signal |
| ACQUIRED | BLAST / BufferItemConsumer | Consumer 已 acquire，后续通过 transaction 进入 SF layer pending / latch 流程 |

`dequeueBuffer` 阻塞通常不是“只等上一帧那块 buffer 回来”。Producer 可以拿任何满足约束的 FREE slot；如果所有可 dequeue 的 slot 都被 DEQUEUED、QUEUED、ACQUIRED 或数量上限占住，才会等。这里要同时看：

- `maxDequeuedBufferCount`：Producer 同时持有的 DEQUEUED slot 是否到顶；
- `maxAcquiredBufferCount`：Consumer / BLAST 侧 ACQUIRED 上限是否到顶；
- QUEUED backlog：新 buffer 是否堆在 Consumer acquire 之前；
- release fence：旧 buffer 退回 FREE 后是否还要等显示硬件释放；
- SF pending / latch：buffer update 到 server 后是否被本轮采纳。

`dequeueBuffer` 长期偏长时，把 slot 状态、acquire / release fence、`BufferTX - <layerName>` 和 latch 放在同一时间轴里，再判断是哪一层没有及时归还可用 buffer。

第一段结构示意只保留 Producer 状态转换，用于确认何时等待 free slot、何时把 slot 标记为 QUEUED。

```text
// Android 17 BufferQueueProducer call skeleton
BufferQueueProducer::dequeueBuffer(...)
    waitForFreeSlotThenRelock()
        if (no slot satisfies the dequeue constraints) {
            if (mDequeueBufferCannotBlock || mAsyncMode)
                return WOULD_BLOCK;
            waitForBufferRelease(...);
        }
    mSlots[found].mBufferState.dequeue();

BufferQueueProducer::queueBuffer(slot, input)
    mSlots[slot].mBufferState.queue();
    item.mFence = input.acquireFence;
    frameAvailableListener->onFrameAvailable(item);
```

`dequeueBuffer()` 返回的 slot 可能同时带有 fence；Producer 必须在写入前遵守它。`queueBuffer()` 的 input fence 在 Consumer 侧成为 acquire fence。

第二段结构示意展示 BLAST 如何把 `BufferItem` 变成 buffer transaction，以及正常 release callback 与 stale-buffer fallback 的区别。

```text
// Android 17 BLASTBufferQueue call skeleton
BLASTBufferQueue::onFrameAvailable(...)
    acquireNextBufferLocked()
        Transaction t;
        t.setBuffer(surfaceControl, buffer, acquireFence, frameNumber, ...);
        t.setFrameTimelineInfo(...);
        t.apply();

BLASTBufferQueue::transactionCallback(...)
    updateFrameTimestamps(..., presentFence, previousReleaseFence, ...)
    for each stale submitted buffer
        releaseBufferCallbackLocked(
            callbackId, previousReleaseFence,
            currentMaxAcquiredBufferCount, fakeRelease=true)

BLASTBufferQueue::releaseBufferCallback(...)
    releaseBufferCallbackLocked(
        callbackId, releaseFence,
        currentMaxAcquiredBufferCount, fakeRelease=false)
        releaseBuffer(...)
            BLASTBufferItemConsumer::releaseBuffer(...)
```

正常路径由 SF release callback / release channel 归还 buffer。Transaction completed callback 中的 fake release 只处理已经被更新帧越过的 stale submitted buffer，不能把所有 release 都归因到 transaction callback。

### 关口 3：`queueBuffer` 之后系统有没有采纳

`queueBuffer` 之后按下列顺序确认系统是否采纳本帧：

- 先看有没有 `queueBuffer`；
- 再看对应 layer 的 `BufferTX - <layerName>` 是否增加；
- 再看这一帧有没有 latch；
- 再看 FrameTimeline actual present 与 present fence。

这些点必须使用同一 frame token、frame number 或邻近时间关系对齐。只看同名 counter 的一次跳变，可能把别的窗口或后续帧配到当前帧。

### 关口 4：系统显示出口怎么判断

App 生产侧按时完成后，继续检查 SurfaceFlinger actual timeline、composition type、HWC / DisplayHAL 与 present timing：

- 前面主线程和 `RenderThread` 都正常；
- `queueBuffer`、`BufferTX - <layerName>`、latch 均落在预期窗口；
- SF actual slice 或 present timing 仍然超出 expected timeline。

SurfaceFlinger actual slice 覆盖 SF 主线程以下的 Composer、DisplayHAL 到 on-screen update，不等于 SF 主线程纯 CPU 时间。结合 `SurfaceFlingerCpuDeadlineMissed`、`SurfaceFlingerGpuDeadlineMissed`、`DisplayHAL` 和 `PredictionError` 才能继续划分系统侧原因。

## 6. Compose 分支：标准 App Window 中哪些工作变了

Jetpack Compose 不会因为采用声明式 UI 就自动创建独立 surface。`ComposeView` / `AbstractComposeView` 仍属于 `ViewRootImpl` 管理的 View hierarchy，Android 端的 Compose 内容通过 HWUI 写入当前 App Window buffer。标准宿主下，`syncAndDrawFrame()` 之后仍经过 RenderThread、BLASTBufferQueue、SurfaceFlinger、HWC 与 present fence。

Compose 改变的是 App 侧生成绘制内容的方式。它独立发布，不能用 `android-17.0.0_r1` 推断 Compose Runtime 或 Compose Compiler 行为。这里按 Android Developers 当前文档中的三阶段模型、strong skipping 与 composition tracing 规则解释；分析具体工程时还要记录 Kotlin、Compose BOM 和 Compose Compiler plugin 版本。

### Compose 影响 1：Composition、Layout、Drawing 可以分别失效

Compose 把 UI 更新分成三个阶段：

1. **Composition**：执行需要重新运行的 `@Composable`，生成或更新 UI tree，回答“显示哪些节点”。
2. **Layout**：测量并放置 layout node，回答“节点多大、放在哪里”。测量和放置拥有各自的 restart scope；只改变 placement 的状态不一定重新 measure。
3. **Drawing**：遍历需要重绘的节点并向 Canvas 发出绘制操作，回答“这些节点怎样画”。只在 draw 阶段读取的状态可以只触发 redraw。

这三个阶段描述依赖关系，不表示每帧都会完整执行三遍。Compose 按状态读取位置记录 invalidation：某个 draw-only 状态变化时，可以跳过 composition 和 layout；UI tree 与尺寸都没变化时，也不应重跑整棵树。

Compose 的常规 layout 使用 single-pass measurement，每个 child 在一次测量过程中只能测量一次。Intrinsic measurement、`SubcomposeLayout`、`BoxWithConstraints`、Lazy layout 和 Lookahead 等机制会改变普通路径，不能用“每个节点只访问一次”解释这些场景。View 系统也不等于固定多次 measure；是否重复取决于父容器实现、layout request 与约束协商。

### Compose 影响 2：Strong skipping 改变了“不稳定参数”的判断

Kotlin 2.0.20 起，strong skipping 默认开启。官方规则可以压成两行：所有 restartable composable 都可被标记为 skippable；比较参数时，stable 参数使用对象相等性，unstable 参数使用实例相等性。`@NonSkippableComposable`、non-restartable composable 以及显式 compiler 配置仍会改变结果。

| 参数或函数状态 | Strong skipping 下的行为 | 分析边界 |
|----------------|--------------------------|----------|
| Restartable composable | 默认可跳过 | 函数体是否执行还取决于参数比较和 invalidation |
| Stable 参数 | 使用 `equals()` 比较新旧值 | `@Stable` 是契约，错误标注可让 UI 漏更新 |
| Unstable 参数 | 使用 `===` 比较实例 | 每次创建新集合会失去跳过机会；复用可变集合又可能绕过可观察状态 |
| Non-restartable / `@NonSkippableComposable` | 不按上述规则跳过 | 不能从参数稳定性单独推断执行次数 |

Perfetto 中 Composition slice 变长只能证明重组工作变多。根因需要结合 Compose compiler report、Layout Inspector 重组计数、状态读取位置和业务 trace marker；“参数 unstable”不能直接推出“每帧重组”。

### Compose 影响 3：Composition tracing 需要工程主动启用

系统 trace 默认不会列出每个 composable 函数。Android Developers 当前文档要求至少使用 Android Studio Flamingo、Compose UI 1.3.0、Compose Compiler 1.3.0 和 API 30 设备，并添加 `androidx.compose.runtime:runtime-tracing`。使用 Compose BOM 时依赖不必单独写版本；使用自定义 Perfetto 配置录制时还要包含 `track_event` data source。

启用后，trace 会记录 composable 源码位置信息与重组事件。具体 slice 名会随 Compose Runtime 版本变化，因此要先确认依赖、trace config 和源码信息，再搜索 `Recomposer`、composition、layout、drawing 与目标 composable 名。没有 composition tracing 时，仍可使用 `Choreographer#doFrame`、`performTraversals()`、`syncAndDrawFrame()` 和 RenderThread 判断窗口级成本，但不能把一段宿主 View 耗时归因到某个 composable。

### Compose 影响 4：互操作不会自动改变出图类型

| 页面结构 | 默认分类 | 需要改分类的条件 |
|----------|----------|------------------|
| View 页面嵌 `ComposeView` | 标准 HWUI | Compose 内容内部创建承载主体内容的独立 surface |
| Compose 页面嵌普通 `AndroidView` | 标准 HWUI | 被嵌 View 自己使用 SurfaceView、TextureView、WebView、Camera 或视频 surface |
| Compose 中嵌 `SurfaceView` | SurfaceView / 混合类型 | 独立 BufferQueue 与 layer 已经出现 |
| Compose 中嵌 `TextureView` | TextureView / 混合类型 | 外部 buffer 经 SurfaceTexture 被宿主 HWUI 采样 |
| Compose 页面主体是 WebView 或跨平台引擎 | 对应引擎类型 | 主体生产节奏与线程由 Chromium / Engine 控制 |

类型判断看 Producer、surface 和 layer，不看页面是否出现 `@Composable`。只要主体结果仍写入当前 App Window buffer，RenderThread 之后就按标准窗口证据分析。

### Compose 影响 5：View 与 Compose 的 trace 入口不同

| 维度 | View hierarchy | Compose hierarchy |
|------|----------------|-------------------|
| 状态到 UI | `invalidate()`、`requestLayout()`、属性更新 | Snapshot 状态失效通知与 Recomposer |
| 布局入口 | `measure()` / `layout()` | Compose measurement / placement restart scope |
| 绘制入口 | `draw()` / `onDraw()`、DisplayList 更新 | Compose drawing phase，经 Android owner 写入 HWUI |
| 专用工具 | Layout Inspector、`gfxinfo`、自定义 trace | Composition tracing、compiler report、重组计数 |
| HWUI 之后 | RenderThread → BLAST → SF → HWC | 同一条标准 App Window 路径 |

Compose 和 View 可以在同一帧里造成不同的 UI 线程成本，但 `queueBuffer` 之后的系统证据含义不变。若 Compose tracing 指向 composition，优化状态读取与跳过；若 UI 线程按时、RenderThread 或 SF 超时，就继续沿标准显示路径查，不要停在框架标签上。

## 7. 为什么标准链适合做性能基线

标准页面的优势是证据容易闭合，不代表它天然更快。目标 App Window 可以用同一组 token 和 layer name 关联下列阶段：

- `Choreographer#doFrame` 提供 UI 帧起点，callback 与 Traversal 暴露主线程成本。
- `syncAndDrawFrame()` 与 RenderThread `DrawFrame` 区分 UI 状态同步、绘制执行和 buffer 提交。
- `BufferTX - <layerName>` 与 latch 说明 buffer transaction 何时进入 SF、何时成为本轮合成输入。
- FrameTimeline 把 App SurfaceFrame 和 SF DisplayFrame 关联起来，并给出 deadline、present type 与 jank type。
- HWC / DisplayHAL 证据帮助区分 SF CPU、GPU composition 和显示后段。

这条证据链适合比较代码改动或系统策略，但比较条件必须一致：刷新率、分辨率、热状态、前后台状态、页面数据量、动画阶段和 trace config 都会改变预算或负载。单次滑动变顺不能证明调度、提频或 BufferQueue 参数发生了变化。

标准路径之外的页面仍可使用相同方法，只是要增加 Producer、surface 或 engine token。Camera、Video、WebView、Flutter 等类型不能只用 App Window 的 FrameTimeline 代表主体内容。

## 8. 系统可调节点：能从 trace 证明什么

AOSP 与 kernel 提供调度、性能提示、BufferQueue 和显示合成机制；设备厂商可以在这些机制之外加入策略。文章只能确认固定源码中存在的接口和算法。某台设备是否提高线程优先级、改变 uclamp、发出 PowerHAL hint 或调整显示策略，必须由该设备的 trace、配置或厂商源码证明。

### 节点 1：先区分执行时间和 runnable 等待

`Choreographer#doFrame` 或 `DrawFrame` 变长时，CPU slice 并不等于线程一直在执行。结合 `sched_wakeup`、`sched_switch` 和线程状态可以分成三类：

- **Running 时间长**：线程获得 CPU 后仍执行很久，优先检查函数调用、锁、IO、布局或绘制工作量。
- **Runnable 时间长**：线程已经可运行却迟迟没有上 CPU，检查 runqueue、优先级、cpuset、uclamp、CPU capacity 与系统竞争。
- **Sleeping / blocked 时间长**：线程等待 futex、Binder、buffer、fence 或其他资源，增加 CPU 频率通常不能解决等待源。

指定 kernel tag 中，`kernel/sched/core.c` 包含调度与 uclamp 主逻辑，`kernel/cgroup/cpuset.c` 管理 cpuset，`kernel/sched/cpufreq_schedutil.c` 根据调度利用率驱动 schedutil。Perfetto 只能记录当时状态；没有策略字段、affinity mask 或 cgroup 变化时，不能写成“绑核”“实时优先级”或厂商专有调度等级。

### 节点 2：ADPF 提供工作时长提示，不保证具体频率

`PerformanceHintManager.Session` 允许应用或系统组件报告目标工作时长和实际工作时长。Android 17 的 HWUI `CanvasContext` 通过 hint session wrapper 更新 workload target、上报 actual duration，并标记活跃的 functor threads。提示会交给 Power HAL / vendor 实现处理；API 契约不保证固定频率、固定 CPU 或每次都提升性能。

验证 ADPF 要同时找三类证据：session 创建与 `reportActualWorkDuration` / target update、Power HAL 或性能数据源中的 hint、随后发生的调度或频率变化。只看到 cpufreq 上升，无法证明是 ADPF 触发；只看到 hint，也无法证明 vendor 采取了动作。

### 节点 3：预取减少未来工作，但不能伪造下一帧状态

RecyclerView GapWorker、Compose lazy prefetch、图片解码预热和 shader / pipeline 缓存都可能把确定性工作移到 deadline 之外。它们减少未来帧的 bind、measure、upload 或 pipeline creation 成本，不改变 Choreographer 的 Input → Animation → Insets Animation → Traversal → Commit 顺序。

`OverScroller` 的位置由时间函数计算，业务或框架可以预取即将出现的 item；这不等于系统已经提交多帧 UI buffer。要证明预取有效，应在 trace 中看到 prefetch slice、目标 item 的 bind / measure 前移，以及随后的关键帧成本下降。没有这些证据时，不应推断“提前补帧”或“预生成后续画面”。

### 节点 4：Android 17 的 BLAST 深度由多个上限共同决定

标准 App Window 的 BufferQueue 位于应用进程。`setMaxDequeuedBufferCount()` 控制 Producer 同时持有的 DEQUEUED buffer 数；`BufferQueueConsumer::setMaxAcquiredBufferCount()` 控制 BLAST Consumer 的 ACQUIRED 上限；`setAsyncMode()` 影响总 slot 计算和 queued buffer 是否可丢弃。

Android 17 没有 `BLASTBufferQueue::setMaxAcquiredBufferCount()` 这个公开方法。BLAST 初始化时通过 SurfaceComposer service 查询 pacesetter display 的最大刷新率所需 acquired count，再调用内部 `BLASTBufferItemConsumer::setMaxAcquiredBufferCount()`。SF 的 release callback 还会携带当前刷新率对应的 acquired count；BLAST 对 EGL producer 可能暂存一部分已 release buffer，以降低当前刷新率低于设备最大刷新率时的延迟。

因此，“队列深度”不是一个独立整数。实际可用 slot 取决于 max dequeued、max acquired、async / non-blocking 模式、当前状态为 DEQUEUED / QUEUED / ACQUIRED 的数量、release fence 以及 BLAST pending release。看到 `dequeueBuffer` 变短，只能证明等待减少，不能证明系统扩大了队列。

### 节点 5：Buffer stuffing recovery 是 Android 17 的具体实现

Android 17 的 `Choreographer` 包含 buffer stuffing recovery。`BBQBufferQueueProducer::waitForBufferRelease()` 统计等待时长，`ViewRootImpl` / `ThreadedRenderer` 把回调接到 `Choreographer.onWaitForBufferRelease()`；等待超过半个 frame interval 后，Choreographer 才标记 stuffed 状态。后续 `doFrame()` 可以故意延迟一个 frame，让 queued buffer 数下降，并在恢复期间调整 animation frame time。`buffer_stuffing_multi_recovery` 控制同一段动画能否多次恢复；启用 `buffer_stuffing_recovery_threshold` 时，`MAX_BUFFER_STUFFING_DELAY_NS` 把累计主动延迟限制在 100 ms。两项都是可变 aconfig flag，设备取值需要从 trace/config 确认。

这套机制解决的是 buffer 已经排队过深造成的额外延迟，不是提高吞吐。Perfetto 可搜索 `Buffer stuffing recovery`、`buffer stuffed`、`Negative offset`，再与 `dequeueBuffer` wait、FrameTimeline `Buffer Stuffing` 和后续 queued count 对齐。看到主动 delay 时，不应把该帧直接归因成 CPU 不足。

### 节点 6：HWC 策略只能从实际 composition 结果判断

SurfaceFlinger 先准备 layer 属性，再由 HWC 返回 composition changes。Android 17 的 `HWComposer::getDeviceCompositionChanges()` 仅在本轮没有 client composition，且满足 earliest-present 条件时尝试 `presentOrValidate()`；否则调用 `validate()`。HWC 能否使用 overlay plane、支持某种 transform、format、dataspace、blend 或 protected content，取决于设备实现和当时资源。

判断 GPU / device composition 要看该帧的 composition type、client composition slice、FrameTimeline `GPU Composition`、HWC trace 或 dumpsys。页面功耗下降、SF slice 变短都不能单独证明某个 layer 使用了 overlay。

### 证据门槛：结论要和观测一一对应

| 想下的结论 | 至少需要的证据 | 不能单独作为证据 |
|------------|----------------|------------------|
| UI / RenderThread 调度等待下降 | 同场景的 runnable delay、线程状态、CPU 落点与优先级/cgroup 对比 | 单帧总时长变短 |
| 系统提高 CPU 能力 | uclamp/cpuset/affinity 或频率轨迹与目标线程时间重合，并排除 thermal 差异 | 线程偶尔跑到大核 |
| ADPF 产生效果 | HintSession 上报、vendor hint 响应、调度/频率变化三者时间相关 | 只有 `PerformanceHintManager` API 调用 |
| BufferQueue 深度改变 | slot / max dequeued / max acquired / async 配置或对应源码，加上排队与延迟变化 | `dequeueBuffer` 变短 |
| Buffer stuffing recovery 生效 | `Buffer stuffing recovery` trace、主动 frame delay、backlog 回落 | FrameTimeline 只显示 `Buffer Stuffing` |
| HWC 使用 device composition | per-layer composition type 或 HWC/FrameTimeline GPU composition 证据 | 功耗下降或 `present fence` 变早 |

这张表同样适用于 OEM 策略分析。AOSP 接口说明“系统可以做什么”，设备 trace 才能说明“这台设备在这次场景里做了什么”。

## 9. 源码入口：优先跟读哪里

Android 平台源码链接全部固定到 Android 17 / API 37 的 `android-17.0.0_r1`：

- [`Choreographer.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/core/java/android/view/Choreographer.java)、[`ViewRootImpl.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/core/java/android/view/ViewRootImpl.java) 与 [view flags](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/core/java/android/view/flags/view_flags.aconfig)：核对 VSync 申请、五类 callback、buffer stuffing recovery、相关 aconfig flag、`scheduleTraversals()` 与 `performTraversals()`。
- [`ThreadedRenderer.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/core/java/android/view/ThreadedRenderer.java)、[`HardwareRenderer.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/graphics/java/android/graphics/HardwareRenderer.java) 与 [HWUI JNI](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/libs/hwui/jni/android_graphics_HardwareRenderer.cpp)：核对 Java UI 线程怎样进入 `syncAndDrawFrame()`。
- [`RenderProxy.cpp`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/libs/hwui/renderthread/RenderProxy.cpp)、[`DrawFrameTask.cpp`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/libs/hwui/renderthread/DrawFrameTask.cpp)、[`CanvasContext.cpp`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/libs/hwui/renderthread/CanvasContext.cpp) 与 [`HintSessionWrapper.cpp`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/libs/hwui/renderthread/HintSessionWrapper.cpp)：核对 UI unblock、绘制、buffer duration 与 HWUI ADPF session。
- [`PerformanceHintManager.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/core/java/android/os/PerformanceHintManager.java)：核对 target duration、actual duration 和 hint session 的 API 契约。
- [`BufferQueueProducer.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/libs/gui/BufferQueueProducer.cpp)、[`BufferQueueConsumer.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/libs/gui/BufferQueueConsumer.cpp) 与 [`BLASTBufferQueue.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/libs/gui/BLASTBufferQueue.cpp)：核对 slot 状态、max dequeued/acquired、async mode、buffer transaction 与 release callback。
- [SurfaceFlinger FrontEnd](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/services/surfaceflinger/FrontEnd/)、[`Layer.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/services/surfaceflinger/Layer.cpp) 与 [`SurfaceFlinger.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/services/surfaceflinger/SurfaceFlinger.cpp)：核对请求状态、snapshot、`BufferTX`、transaction readiness、latch 与当前刷新率对应的 acquired count。
- [`HWComposer.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/services/surfaceflinger/DisplayHardware/HWComposer.cpp) 与 [FrameTimeline](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/services/surfaceflinger/Scheduler/FrameTimeline.cpp)：核对 validate/present、release fence 和 SurfaceFrame / DisplayFrame。

Kernel 机制固定到 `android17-6.18-2026-06_r6`：

- [`kernel/sched/core.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/kernel/sched/core.c)、[`kernel/cgroup/cpuset.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/kernel/cgroup/cpuset.c)：核对调度、uclamp 与 cpuset 约束。
- [`kernel/sched/cpufreq_schedutil.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/kernel/sched/cpufreq_schedutil.c)、[`drivers/cpufreq/cpufreq.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/drivers/cpufreq/cpufreq.c)：核对调度利用率到 cpufreq policy 的入口。Vendor governor、Power HAL 与设备热策略不在这些文件中，仍需设备证据。

Compose 独立于 platform tag，使用官方文档确认版本相关行为：

- [Compose phases](https://developer.android.com/develop/ui/compose/phases)：确认 Composition、Layout、Drawing 与各阶段状态读取。
- [Strong skipping mode](https://developer.android.com/develop/ui/compose/performance/stability/strongskipping)：确认 Kotlin 2.0.20 默认值、restartable/skippable 与参数比较规则。
- [Composition tracing](https://developer.android.com/develop/ui/compose/tooling/tracing)：确认最低版本、`runtime-tracing` 依赖和 `track_event` 配置。
- [`ComposeView` API](https://developer.android.com/reference/kotlin/androidx/compose/ui/platform/ComposeView) 与 [View/Compose interoperability](https://developer.android.com/develop/ui/compose/migrate/interoperability-apis/compose-in-views)：确认宿主 View 与互操作边界。

Perfetto 的字段与 jank 分类以 [FrameTimeline 文档](https://perfetto.dev/docs/data-sources/frametimeline) 和 [PerfettoSQL standard library](https://perfetto.dev/docs/analysis/stdlib-docs) 为准。滚动文档用于解释 trace 数据，平台实现判断仍回到固定 AOSP tag。


## 10. 版本演进：Android 12 到 Android 17

标准 HWUI 页面的现代基线从 Android 12 开始。这里跟踪的是 `Choreographer → ViewRootImpl / Compose host → HWUI RenderThread → App Window BLAST → SurfaceFlinger → HWC`。某个版本新增 API，不一定改变这条 Producer 到 display 的拓扑；只有影响帧调度、buffer transaction、latch、composition 或可观察证据时，才需要改变排查方法。

| 平台 | 标准页面相关变化 | Review 与 Perfetto 影响 |
|---|---|---|
| Android 12 / API 31 | App Window 已使用 BLAST；FrameTimeline 从 Android 12 起可用；`PerformanceHintManager` 在 API 31 公开 | 标准页可以用 SurfaceFrame/DisplayFrame expected 与 actual 时间线；ADPF 只能当 hint 证据，不能当频率保证 |
| Android 13 / API 33 | SurfaceFlinger 默认支持 `AutoSingleLayer` latch unsignaled buffer | transaction latch 与 acquire fence signal 可以分离；仍需在 RenderEngine/HWC 读取前满足 fence |
| Android 14 / API 34 | 对标准 App Window，主链继续沿用 Android 12/13 的 Choreographer、HWUI、BLAST 与 SF/HWC 拓扑，没有需要更换分类方法的公开结构变化 | Android 14 标准页仍按同一条链排查；不要把 SurfaceView 的 alpha/lifecycle 变化套到普通 App Window |
| Android 15 / API 35 | Window 可请求 desired HDR headroom；target SDK 35 的系统 UI/insets 行为也可能改变布局工作量，但主体仍写入同一个 App Window | HDR 与 edge-to-edge 问题会改变状态、颜色或 Traversal 成本，不会自动把页面变成独立 Surface 类型 |
| Android 16 / API 36 | 标准 HWUI/BLAST 主拓扑继续沿用；本篇没有发现需要改写 12 阶段主流程的公开结构替换 | 跨版本对比应先保持刷新率、编译器、Compose、设备固件和应用代码一致，再归因到平台 |
| Android 17 / API 37 | 本文源码锚点：FrontEnd snapshot、现行 BLAST acquired-count 管理、buffer stuffing recovery、预测 present time 与 HWC skip-validate 流程 | 方法名和 flag 按 `android-17.0.0_r1` 解读；这些机制是否为 Android 17 首次引入，要另查历史 tag，不能从当前源码反推 |

### Android 12：BLAST、FrameTimeline 与 ADPF 基线

Android 12 已经具备本文标准页的三组核心能力。

第一，App Window 的 Producer 通过 `Surface` / BufferQueue 提交 buffer，应用进程内的 BLAST Consumer 把 `BufferItem` 转为 `SurfaceComposerClient::Transaction`。这使 buffer、frame number、dataspace、transform 和相关 transaction 状态沿 SurfaceControl 事务进入 SurfaceFlinger。`queueBuffer()`、BLAST acquire、SF server 收到 BufferTX 仍是不同时间点。

第二，FrameTimeline 提供 expected/actual `SurfaceFrame` 与 `DisplayFrame`。标准 App Window 通常是它覆盖最完整的场景，可以按 `surface_frame_token`、`display_frame_token`、`layer_name`、`jank_type` 和 `present_type` 对齐应用与显示帧。

第三，API 31 的 `PerformanceHintManager` 允许用 target duration 和 actual duration 向系统报告工作负载。它是 ADPF 契约的起点，不承诺线程固定迁核、CPU 固定频率或每次 hint 都产生可见调度变化。

### Android 13：latch unsignaled 改变“SF 在哪里等”

Android 13 起，`AutoSingleLayer` 成为官方文档描述的默认 latch unsignaled 模式。对于满足条件的单 layer 简单 buffer update，SurfaceFlinger 可以先让 transaction 通过 readiness，再在更靠近内容读取的位置遵守 acquire fence。

标准页的排查顺序因此要保留两次确认：

1. buffer transaction 是否已经被 SurfaceFlinger 采纳；
2. RenderEngine 或 HWC 使用该 buffer 前，acquire fence 是否按时 signal。

“SF 已 latch”不能证明 GPU 完成；“queueBuffer 时 fence 未 signal”也不能证明 transaction 必然错过本轮 latch。是否满足 simple update、单 layer、队列顺序和调度配置，要用该版本源码与 trace 判断。

### Android 14：分类方法保持稳定

Android 14 对标准 App Window 没有公开的 Producer/Consumer 拓扑换代。普通 View 与纯 Compose 仍由宿主 ViewRoot/HWUI 生成同一个 App Window buffer，SurfaceFlinger 仍按 layer transaction 与 HWC strategy 完成显示。

这一版在 SurfaceView 上增加任意 alpha 和公开 lifecycle 策略，但这些是独立 Surface 分支的行为。标准页面如果没有独立 buffer layer，就不应因为使用 Android 14 而套用 hole-punch、SurfaceHolder 或 SurfaceView Z-order 结论。

### Android 15：HDR 与布局策略不改变出图类型

API 35 的 `Window.setDesiredHdrHeadroom()` 为宿主窗口表达期望 HDR/SDR 比例。它影响显示策略输入，不改变“主体像素写入 App Window buffer”这一分类事实。请求能否实现还取决于 window color mode、buffer 格式/bit depth、dataspace、面板与 HWC/RenderEngine 能力。

target SDK 35 的 edge-to-edge 行为可能让 insets 处理、布局区域和遮挡关系发生变化，进而增加或转移 Traversal / Drawing 成本。它属于宿主 View 状态变化；除非页面另行创建独立 Surface，仍按标准类型分析。

### Android 16：主拓扑延续，控制实验更重要

Android 16 的标准 HWUI 页面继续沿用 Choreographer、ViewRootImpl、RenderThread、BLAST、SurfaceFlinger 和 HWC。没有影响本文分类的公开主拓扑替换时，版本对比应避免写成“升级系统导致渲染链改变”。

至少控制这些变量：设备/SoC 与 vendor image、刷新率和分辨率、应用构建与 profile、Kotlin/Compose 版本、热状态、Power HAL 策略、输入脚本和数据量。AOSP 主线相同不代表设备策略相同，反过来也不能把设备差异包装成 AOSP 架构差异。

### Android 17：本文的精确源码口径

Android 17 的标准页按这些当前实现解释：

- `Choreographer` 用 pending frame 状态合并 VSync 申请，并包含 buffer stuffing recovery 及相关 aconfig flag；
- HWUI `CanvasContext` / `HintSessionWrapper` 管理 RenderThread 绘制与 hint session 上报；
- BLAST 的 acquired buffer 上限、刷新率反馈和 release 缓存共同影响队列深度，源码没有公开的 `BLASTBufferQueue::setMaxAcquiredBufferCount()`；
- SurfaceFlinger FrontEnd 以 `RequestedLayerState` 和 `LayerSnapshot` 组织当前状态；
- HWC 只有满足条件时尝试 `presentOrValidateDisplay()`，`PresentSucceeded` 表示这次组合调用已 present 并保存 fences，不表示 panel 已完成扫描。

这些是 Android 17 Review 的当前事实，不自动等同于 Android 17 新增功能。文章描述“Android 17 的实现”时指固定 tag 中的代码；描述“从某版本开始”时必须有对应旧 tag 或公开 API 文档支持。

### Compose 版本必须单独记录

Jetpack Compose 不随 Android platform tag 发布。同一台 Android 14、15、16 或 17 设备，可以运行不同 Compose 运行时、compiler plugin 和 Kotlin 版本。Compose strong skipping 从 Kotlin 2.0.20 起默认开启，这个边界不能写成“Android 15/16/17 默认开启”。

做跨版本实验时，报告里至少记录：

- Android platform build / tag 与设备 vendor build；
- Kotlin 和 Compose compiler plugin 版本；
- Compose BOM 或 Runtime / UI 具体版本；
- 是否加入 `runtime-tracing` 以及 tracing 配置；
- release/profileable/debug 构建方式与 baseline profile 状态。

只有平台与 Jetpack 版本都固定，Composition、Layout、Drawing 的 slice 差异才有可比性。

### 固定版本来源

- [Android 12 `BLASTBufferQueue.cpp`](https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-12.0.0_r1/libs/gui/BLASTBufferQueue.cpp)、[FrameTimeline](https://perfetto.dev/docs/data-sources/frametimeline)、[`PerformanceHintManager`](https://developer.android.com/reference/android/os/PerformanceHintManager)：确认 Android 12 基线；
- [Android 13 unsignaled buffer latch](https://source.android.com/docs/core/graphics/unsignaled-buffer-latch)：确认默认模式与限制；
- [Android 14 `ViewRootImpl.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-14.0.0_r1/core/java/android/view/ViewRootImpl.java) 与 [`SurfaceView` API](https://developer.android.com/reference/android/view/SurfaceView)：分开核对标准窗口主线和独立 Surface 分支；
- [API 35 `Window.setDesiredHdrHeadroom()`](https://developer.android.com/reference/android/view/Window#setDesiredHdrHeadroom%28float%29) 与 [edge-to-edge enforcement](https://developer.android.com/develop/ui/views/layout/edge-to-edge)：确认 Android 15 行为边界；
- [Android 16 `ViewRootImpl.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-16.0.0_r1/core/java/android/view/ViewRootImpl.java)：确认标准窗口拓扑延续；
- [Android 17 `Choreographer.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/core/java/android/view/Choreographer.java)、[BLAST](https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-17.0.0_r1/libs/gui/BLASTBufferQueue.cpp) 与 [SurfaceFlinger FrontEnd](https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-17.0.0_r1/services/surfaceflinger/FrontEnd/)：确认本文当前调用名和 flag。


## 11. Perfetto 证据链：按标准路径排查

标准 App Window 的证据按 Producer 到 display 的方向排列。先确认目标进程与 layer，再沿同一 frame token 检查 UI、RenderThread、buffer transaction、latch 和 present。

| 步骤 | 要确认的事 | 常用信号 |
|------|------------|----------|
| App 收帧 | 目标进程是否正常接到 `vsync-app` | `Choreographer#doFrame`、FrameTimeline app frame |
| 主线程阶段 | 哪个 callback 或 Traversal 子段先膨胀 | `INPUT`、`ANIMATION`、`INSETS_ANIMATION`、`TRAVERSAL`、`COMMIT`，以及 `performTraversals()` / `performDraw()` |
| UI 到 RT | Traversal 末尾交给 RenderThread 是否卡住 | `syncAndDrawFrame()`、`DrawFrameTask`、UI unblock |
| RT 到 BufferQueue | 是绘制执行慢，还是拿 buffer / 交 buffer 慢 | `DrawFrame`、`dequeueBuffer`、`queueBuffer`、`QueueBufferDuration` |
| App 到 SF | buffer update 是否进入系统侧并被采纳 | `BufferTX - <layerName>`、SF transaction、latch |
| 系统出口 | 合成和 present 是否延迟 | SF actual timeline、composition type、HWC / DisplayHAL、present / release fence |

### 证据 1：先确认问题仍在标准链

1. 用进程名、`upid` 和 layer name 锁定目标 App Window，避免把 SystemUI 或另一个 surface 的帧混进来。
2. 查看 `Choreographer#doFrame` 中 Input、Animation、Insets Animation、Traversal 与 `syncAndDrawFrame()`。
3. 查看 RenderThread 的 `DrawFrame`、`dequeueBuffer`、GPU 工作和 `queueBuffer`。
4. 对齐 `BufferTX - <layerName>`、transaction、latch 与 App SurfaceFrame。
5. 使用 SF DisplayFrame、composition type、HWC / DisplayHAL 和 present timing 判断显示出口。

### 证据 2：再按主线程和 RenderThread 分工

- `main`
  - 看标准窗口这一帧的 Input / Animation / Traversal 有没有先慢下来。
- `RenderThread`
  - 看当前窗口内容是不是按时生产出来。
- `SurfaceFlinger`
  - 看系统这一轮有没有把当前窗口正常采纳。

### 证据 3：用关键切片定位阶段

- `Choreographer#doFrame`（Perfetto 中搜索这个 slice 名即可定位帧起点）
- `DrawFrame`（RenderThread 上的核心 slice，覆盖 `DrawFrameTask::run()` / `CanvasContext::draw()` 的执行区间；UI 线程上的 `syncAndDrawFrame()` 只是触发它的入口，不是同一段时间）
- `queueBuffer`
- `BufferTX - <layerName>`
- SF 侧 transaction / latch / FrameTimeline
- `present fence` 相关信号

### 证据 4：FrameTimeline 要分开看预期和实际

FrameTimeline 是判断标准链有没有 jank 的主要入口。比较 deadline 时使用完整区间：

- expected end = `expected_frame_timeline_slice.ts + expected_frame_timeline_slice.dur`；
- actual end = `actual_frame_timeline_slice.ts + actual_frame_timeline_slice.dur`；
- overrun = actual end - expected end。

App 侧和 SF / Display 侧的 token 要分开看。App `SurfaceFrame` 使用 `surface_frame_token` 关联应用工作和 layer 提交；SF / Display 侧使用 `display_frame_token` 表示合成后的显示帧。一帧 DisplayFrame 可以包含多个进程的 SurfaceFrame，两种 token 不能合并成一个“全程 token”。

`jank_type` 用于初步分类，不能单独当根因。`Buffer Stuffing` 表示排队帧增加并带来额外延迟；继续核对 `present_type`、`on_time_finish`、`BufferTX - <layerName>`、latch、`dequeueBuffer` wait、release fence 和 recovery trace，才能说明积压怎样形成、怎样消退。

下面的 PerfettoSQL 把目标 App 的 actual SurfaceFrame 与 expected SurfaceFrame 按 token 对齐，并计算结束时间差。`ts`、`dur` 和计算结果的单位都是纳秒；替换包名后仍要用 `layer_name` 过滤目标窗口。

```sql
WITH app_actual AS (
  SELECT
    a.*,
    p.name AS process_name
  FROM actual_frame_timeline_slice AS a
  LEFT JOIN process AS p USING (upid)
  WHERE a.surface_frame_token != 0
),
app_expected AS (
  SELECT
    upid,
    surface_frame_token,
    ts AS expected_ts,
    dur AS expected_dur
  FROM expected_frame_timeline_slice
  WHERE surface_frame_token != 0
)
SELECT
  a.surface_frame_token,
  a.display_frame_token,
  a.ts AS actual_ts,
  a.dur AS actual_dur,
  e.expected_ts,
  e.expected_dur,
  (a.ts + a.dur) - (e.expected_ts + e.expected_dur) AS overrun_ns,
  a.jank_type,
  a.present_type,
  a.on_time_finish,
  a.layer_name
FROM app_actual AS a
LEFT JOIN app_expected AS e
  ON a.upid = e.upid
  AND a.surface_frame_token = e.surface_frame_token
WHERE a.process_name = 'com.example.app'
  AND a.layer_name GLOB '*com.example.app*'
ORDER BY a.ts;
```

`overrun_ns > 0` 说明 actual end 晚于 expected end，但仍需结合 `jank_type` 和线程轨迹判断原因。相同 token 出现多个 layer 记录时，按目标 `layer_name` 过滤或在统计前去重。

### 证据 5：按顺序复原一帧

- 主线程：确认帧起点与 UI 状态准备。
- RenderThread：确认状态同步、绘制、buffer 获取与提交。
- BLAST / SF：对齐 `queueBuffer`、`BufferTX - <layerName>`、transaction 与 latch。
- DisplayFrame：确认 composition、HWC / DisplayHAL 与 present。

如果这一整条链都能对上，而且页面又没有明显独立 `Surface`、浏览器内核、引擎主体或硬件 Producer，那它大概率就是标准类型。

## 12. 类型边界：和相邻类型分开

### 和 `SurfaceView` 的区别

`SurfaceView` 拥有独立 BufferQueue 和 SurfaceControl layer。它可以位于同一窗口层级中，但内容 buffer 不写入宿主 App Window；标准类型的主体内容只写入 App Window buffer。

### 和 `TextureView` 的区别

`TextureView` 通过 SurfaceTexture 接收外部 Producer 的 buffer，再由宿主 HWUI 将其作为纹理采样进 App Window。SurfaceFlinger 通常只接收合成后的宿主窗口 buffer；标准类型没有这条额外 SurfaceTexture 输入。

### 和 W

GENERATED FILE - DO NOT EDIT.
Source: docs/rendering_pipelines/S03_surfaceview_type.md
Source SHA-256: bc36006cf53cb28f45d888aa4f9fbf28c4f6a3e0b511be7f8db36857c1e26630

# Android Perfetto 系列 - App 出图类型 - SurfaceView 类型

`SurfaceView` 把一块可见内容交给独立 `Surface`。宿主窗口继续绘制按钮、字幕、遮罩和其它 View，视频、相机预览、地图或游戏画面则由另一套 Producer 直接向独立 BufferQueue 提交 buffer。两路内容到 SurfaceFlinger 才组成最终画面。

分析这类 trace，先把“宿主窗口帧”和“SurfaceView 内容帧”拆开。两者可能由不同进程、不同线程、不同帧率驱动，也各自持有 buffer、fence 和 transaction 状态。只看应用主线程或宿主 `RenderThread`，无法解释画面主体的完整链路。

<!--more-->

## 阅读导航

### 本文目录

- 阅读说明
- 1. 一帧完整流程：两条生产线怎样到达屏幕
- 2. 类型判定：什么证据能确认 SurfaceView
- 3. 形成原因：独立 Surface 解决了什么问题
- 4. 系统结构：宿主、容器层和 BLAST 层
- 5. 版本演进：Android 12 到 Android 17
- 6. 生命周期：Producer 什么时候可以使用 Surface
- 7. 起跑节奏：宿主帧和内容帧由谁驱动
- 8. 汇合过程：buffer、几何、fence 和 HWC
- 9. 源码入口：Android 17 应该跟读哪里
- 10. Perfetto 证据链：怎样复原一帧
- 11. 类型边界：与标准窗口、TextureView 和混合出图区分
- 12. 故障模式：从现象回到责任对象
- 总结

### 系列文章目录

1. [Android Perfetto 系列 - App 出图类型 - 总览与识别方法](S01_rendering_types_overview.md)
2. [Android Perfetto 系列 - App 出图类型 - AOSP 标准类型](S02_aosp_standard_type.md)
3. [Android Perfetto 系列 - App 出图类型 - SurfaceView 类型](S03_surfaceview_type.md)
4. [Android Perfetto 系列 - App 出图类型 - TextureView 类型](S04_textureview_type.md)
5. [Android Perfetto 系列 - App 出图类型 - 混合出图类型](S05_mixed_rendering_type.md)
6. [Android Perfetto 系列 - App 出图类型 - 多窗口类型](S06_multi_window_type.md)
7. [Android Perfetto 系列 - App 出图类型 - Software / 离屏类型](S07_software_offscreen_type.md)
8. [Android Perfetto 系列 - App 出图类型 - Native Graphics 类型](S08_native_graphics_type.md)
9. [Android Perfetto 系列 - App 出图类型 - WebView 类型](S09_webview_type.md)
10. [Android Perfetto 系列 - App 出图类型 - Flutter 类型](S10_flutter_type.md)
11. [Android Perfetto 系列 - App 出图类型 - Camera 类型](S11_camera_type.md)
12. [Android Perfetto 系列 - App 出图类型 - Video Overlay / HWC 类型](S12_video_overlay_hwc_type.md)
13. [Android Perfetto 系列 - App 出图类型 - Game 类型](S13_game_type.md)
14. [Android Perfetto 系列 - App 出图类型 - React Native 类型](S14_react_native_type.md)

## 阅读说明

本文的平台源码固定到 Android 17 / API 37 的 `android-17.0.0_r1`，kernel 源码固定到 `android17-6.18-2026-06_r6`。`SurfaceView`、BLAST、SurfaceFlinger 和 HWC 的调用名按平台 tag 核查；dma-fence 与 sync file 的底层语义按指定 kernel tag 核查。厂商 codec、camera HAL、gralloc、DPU 和 Composer HAL 的实现不在 AOSP 公共源码里，涉及这些模块时必须结合目标设备 trace 与 dump。

版本演进以 Android 12 为起点。更早版本只保留一条仍影响当前 API 解释的兼容信息：Android 官方文档说明，从 Android 7.0 起，`SurfaceView` 的窗口位置会与 View 层级渲染同步更新；旧设备上的异步位置伪影不属于本文 Android 12 之后的主链路。

文中的“SurfaceView layer”是便于分析的统称。Android 17 的应用进程内并非只有一个 `SurfaceControl`：`SurfaceView` 会维护容器层、BLAST buffer layer 和按条件显隐的背景 color layer。SurfaceFlinger FrontEnd 再把 transaction 状态整理成 `RequestedLayerState` 与 `LayerSnapshot`，不能用早期单个 `Layer` 对象的模型解释全部细节。

## 1. 一帧完整流程：两条生产线怎样到达屏幕

以“宿主控制条覆盖在视频 SurfaceView 上”为例，一次屏幕更新包含下面几组工作：

1. 宿主窗口因为输入、动画、布局或重绘请求安排下一帧。`Choreographer` 在没有 pending frame 时请求 `vsync-app`，随后主线程进入 `doFrame()`。
2. 主线程依次处理 `INPUT → ANIMATION → INSETS_ANIMATION → TRAVERSAL → COMMIT`。Traversal 更新普通 View 树，也计算 `SurfaceView` 的位置、尺寸、裁剪、可见性和相对 Z-order。
3. 宿主窗口通过 `ThreadedRenderer.syncAndDrawFrame()` 把绘制状态交给 RenderThread。RenderThread 从宿主窗口的 BLAST 队列取得 buffer，绘制控制条、字幕、遮罩以及默认 Z-below `SurfaceView` 对应的 hole-punch 区域。
4. 独立 Producer 按自己的节奏生成内容。它可能是应用内 EGL/Vulkan 线程，也可能是 codec、camera provider/HAL 或厂商服务参与的跨进程流水线。
5. Producer 从 `SurfaceView` 暴露的 `Surface` 取得可写 buffer，填充后提交 buffer 和完成 fence。这个完成 fence 在 Consumer 一侧成为读取该 buffer 的 acquire fence。
6. Android 17 的 `SurfaceView` 用 `BLASTBufferQueue` 把新 buffer 组织成针对 BLAST layer 的 transaction。与下一块内容 buffer 绑定的外部 transaction，也可以按 frame number 暂存后合并。
7. 宿主几何更新由 `RenderNode.PositionUpdateListener` 生成 `SurfaceControl.Transaction`，再通过 `ViewRootImpl.mergeWithNextTransaction()` 与宿主目标帧合并。UI 线程上的其它 SurfaceView 状态通常通过 `applyTransactionOnDraw()` 随 ViewRoot 下一次 draw transaction 提交。
8. SurfaceFlinger 接收宿主窗口和 SurfaceView 子层的 transaction。FrontEnd 更新 layer 状态和 snapshot；进入合成前，各 buffer layer 分别检查新 buffer、几何状态与 acquire fence 条件。
9. 某个 layer 没有新 buffer 时，可以沿用上次已合成内容。存在新 buffer 但同步条件未满足时，可能推迟采纳；不能据此推断另一条 layer 也会一起等待。
10. CompositionEngine 与 HWC 为每个 layer 协商 composition type。允许 skip validate 时先调用 `presentOrValidateDisplay()`；否则调用 `validateDisplay()`。满足设备能力和保护要求的 SurfaceView layer 可能走 device composition，普通 layer 不满足条件时可能被改为 client composition。
11. `presentOrValidateDisplay()` 返回 `PresentSucceeded` 时，这次 HAL 调用已经执行 present 并保存 fences。返回 `Validated` 或走普通 validate 路径时，SurfaceFlinger 读取 composition changes；若存在 CLIENT layer，RenderEngine 生成 client target，SurfaceFlinger 调用 `setClientTarget()`，随后才用 `presentAndGetReleaseFences()` 收尾。
12. 两条 present 路径最终都得到 present fence 与各 layer 的 release fence。fence fd 返回时通常尚未 signal；present fence 之后的 signal 是 Android 显示栈可观察的 present 边界，不等于面板扫描、光学响应或用户感知完成。release fence 则控制旧 buffer 何时能被对应 Producer 安全复用。

### 显示链路图

这张图把宿主窗口、SurfaceView 内容层和显示合成放在同一条时间线上，用来标出两条生产线各自的提交点与汇合点。

```mermaid
sequenceDiagram
    participant Host as "Host main / ViewRoot"
    participant RT as "Host RenderThread / BLAST"
    participant Producer as "SurfaceView Producer"
    participant SV as "SurfaceView BLASTBufferQueue"
    participant SF as "SF FrontEnd / CompositionEngine"
    participant HWC as "HWComposer / Composer HAL"
    participant DD as "Display driver"

    Host->>Host: invalidate / layout / animation schedules frame
    SF-->>Host: vsync-app prediction callback
    Host->>Host: doFrame: INPUT → ANIMATION → INSETS → TRAVERSAL → COMMIT
    Host->>RT: syncAndDrawFrame(host UI + hole-punch)
    RT->>RT: dequeue host buffer + GPU work
    RT->>SF: host buffer transaction: BufferTX - host layer

    Producer->>SV: dequeueBuffer
    Producer->>Producer: codec / camera / EGL / Vulkan fills buffer
    Producer->>SV: queueBuffer(buffer + completion fence)
    SV->>SF: SurfaceView buffer transaction: BufferTX - SV BLAST layer

    Host->>SF: position / crop / visibility / relative-Z transaction
    SF->>SF: update RequestedLayerState and LayerSnapshot
    SF->>SF: per-layer latch / acquire-fence readiness
    SF->>HWC: 提交 layer 状态并协商合成策略
    alt skip-validate path available
        SF->>HWC: presentOrValidateDisplay
        alt PresentSucceeded
            HWC-->>SF: present executed, present/release fences saved
        else Validated
            HWC-->>SF: changed composition types / requests
            SF->>HWC: acceptChanges
            opt any CLIENT layer
                SF->>SF: RenderEngine composes client target
                SF->>HWC: setClientTarget(output acquire fence)
            end
            SF->>HWC: presentDisplay（当前轮尚未 present）
            HWC-->>SF: present fence fd + per-layer release fence fds
        end
    else validate path
        SF->>HWC: validateDisplay
        HWC-->>SF: changed composition types / requests
        SF->>HWC: acceptChanges
        opt any CLIENT layer
            SF->>SF: RenderEngine composes client target
            SF->>HWC: setClientTarget(output acquire fence)
        end
        SF->>HWC: presentDisplay
        HWC-->>SF: present fence fd + per-layer release fence fds
    end
    HWC->>DD: 提交 display frame
    DD-->>SF: present fence 后续异步 signal
    SF-->>RT: host release channel
    SF-->>SV: SurfaceView release channel
    SV-->>Producer: release fence gates buffer reuse
```

图里有三个容易混淆的边界：

- `PresentSucceeded` 表示合并的 Composer HAL 调用走了 present 分支，并把 present/release fences 保存下来；它不表示面板已经完成扫描。
- `BufferTX - <layerName>` 是按 layer 区分的 buffer transaction 计数或轨迹。宿主和 SurfaceView 应分别观察，不能把两条 counter 当成同一队列。
- View 树只负责宿主 buffer 和 SurfaceView 的管理状态。独立内容 buffer 不会先画进宿主 buffer 再交给 SurfaceFlinger。

## 2. 类型判定：什么证据能确认 SurfaceView

一个页面包含视频或相机预览，不足以证明它使用 `SurfaceView`。MediaCodec、Camera、WebView、游戏引擎都可以把内容接到不同类型的输出目标。判定应建立在 layer、BufferQueue 和 Producer 三类证据上。

### 最小证据集

1. **宿主窗口仍有独立输出**：应用主线程和 RenderThread 继续生成宿主窗口帧，SurfaceFlinger 中存在宿主 App Window layer。
2. **主体内容拥有独立 buffer layer**：layer tree 或 trace 中能找到与 SurfaceView 对应的子层，并看到它自己的 buffer 更新。
3. **两条 buffer 节奏可分离**：宿主窗口与主体内容的 `queueBuffer`、`BufferTX - <layerName>`、acquire/release fence 时序并不完全一致。
4. **几何由 SurfaceControl 管理**：移动、裁剪、显隐或 Z-order 变化体现为 SurfaceView 子树的 transaction，而不是只体现为宿主 HWUI 重绘。

### 仅凭这些信号不能定型

- 看到 `Surface`、EGL swap 或 Vulkan present：普通窗口和 TextureView 也会使用 Surface/BufferQueue。
- 看到 MediaCodec 或 camera 线程：它说明存在媒体 Producer，不说明最终 Consumer 是 SurfaceView。
- 看到 HWC overlay：普通窗口 layer 也可能走 device composition；SurfaceView 也可能因为设备约束走 client composition。
- 看到宿主主线程很空：主体可能独立生产，但也可能只是页面静止。

确认类型后，再回答三个问题：主体 buffer 在哪里生产、几何 transaction 由谁提交、两者在哪一轮 SurfaceFlinger 合成里相遇。

## 3. 形成原因：独立 Surface 解决了什么问题

`SurfaceView` 的价值来自“独立 buffer stream”，不是控件名称。

视频解码器、Camera HAL、EGL/Vulkan 渲染器通常已经能直接生成可显示 buffer。如果先把这些 buffer 采样进宿主 View 树，再由宿主窗口重画，会增加一次纹理采样与合成约束，还会把主体内容的更新节奏绑到宿主 HWUI 帧。独立 Surface 允许 Producer 直接把 buffer 提交给 SurfaceFlinger，并让 HWC 按 layer 评估硬件合成能力。

这条路径适合以下情况：

- 主体内容尺寸大、更新频繁，且已有独立 Producer；
- 视频或相机内容需要保留自己的帧率、色彩空间、HDR 或 protected 属性；
- 设备可能用 overlay plane、scaler 或其它 display hardware 直接处理该 layer；
- 宿主 UI 更新频率与主体内容不同，希望两者各自推进。

代价同样明确：

- 生命周期不再等同于 Activity 生命周期；
- 主体内容不在宿主 HWUI buffer 内，复杂 View 变换、shader、任意混合与截图语义需要重新判断；
- 宿主 hole-punch、SurfaceView 几何和内容 buffer 分属不同状态源，错误同步会出现一帧错位；
- 多个独立 layer 会增加 HWC strategy 的约束，overlay plane 也不是无限资源。

选择 `SurfaceView` 时，应把“少一次宿主采样的机会”和“多一套独立生命周期及同步关系”一起评估。

## 4. 系统结构：宿主、容器层和 BLAST 层

### 4.1 Android 17 的对象关系

Android 17 的 `SurfaceView.createBlastSurfaceControls()` 会维护三类 `SurfaceControl`：

- `mSurfaceControl`：container layer，挂到 `ViewRootImpl.updateAndGetBoundsLayer()` 返回的 bounds layer 下，承载位置、裁剪、相对层级等管理状态；
- `mBlastSurfaceControl`：container 的 child BLAST layer，接收 Producer 提交的内容 buffer；
- `mBackgroundControl`：创建在 container 下的 color layer，在默认 Z-below、内容被声明为 opaque 等条件满足时显示。

对应关系可以写成：

```text
ViewRoot bounds layer
└── SurfaceView container: mSurfaceControl
    ├── content BLAST layer: mBlastSurfaceControl
    └── background color layer: mBackgroundControl
```

这段结构用于读 layer tree。几何状态主要落在 container，内容 buffer 落在 BLAST child；分析时如果只按名字找到 container，却没有继续找到实际携带 buffer 的 child，会把“几何已更新”误写成“内容已提交”。

`BLASTBufferQueue` 由应用进程内的 `SurfaceView` 创建并更新，`SurfaceHolder.getSurface()` 暴露的是 Producer 侧 `Surface`。Producer 可以在同进程，也可以通过 Binder 把 `IGraphicBufferProducer` 能力交给 codec 或 camera 流水线。不能用“SurfaceView 的 Java 对象在应用进程”推出“buffer 填充一定发生在应用进程”。

### 4.2 默认 Z-below 与 hole-punch

默认 composition order 为负，SurfaceView container 位于宿主窗口下方。宿主窗口必须在对应区域留下可透出的部分，下面的内容 layer 才能显示。

Android 17 源码里的关键行为是：

- `gatherTransparentRegion()` 在 SurfaceView 位于宿主下方且绘制已经完成时，参与收集透明区域；
- `draw()` 或 `dispatchDraw()` 根据 `PFLAG_SKIP_DRAW` 分工调用 `clearSurfaceViewPort()`；
- `clearSurfaceViewPort()` 使用 `Canvas.punchHole()`，并结合 View bounds、clip bounds、corner radius 与 alpha；
- `mDrawFinished` 为 false 或 SurfaceView 位于宿主上方时，不走这套默认 hole-punch 条件。

所以，“SurfaceView 挖洞”不是一条固定的 `PorterDuff.Mode.CLEAR` 调用，也不是 SurfaceFlinger 自动在宿主 buffer 上删像素。它是宿主 View 绘制、透明区域和 SurfaceControl 层级共同形成的显示结果。

### 4.3 composition order 与 alpha

Android 17 可用 `setCompositionOrder(int)` 明确控制相对顺序：

| order | 相对宿主窗口 | alpha 落点 | 常见效果 |
|---|---|---|---|
| `< 0` | 宿主窗口下方 | 作用于 hole-punch，不直接调制 Surface 内容 | 宿主按钮、字幕可覆盖在主体内容上 |
| `>= 0` | 宿主窗口上方 | 直接作用于 Surface 内容 | 主体会盖住宿主窗口中重叠的 View |

order 越大，SurfaceView peer 之间的层级越高；相同 order 的相对顺序未定义。旧入口 `setZOrderMediaOverlay()` 与 `setZOrderOnTop()` 在 Android 17 源码里已标记 deprecated，并由 feature flag 管理 API 暴露。面向 API 36 及以上的新代码应优先评估 `setCompositionOrder()`；兼容旧 target 或旧平台时仍需按公开 SDK 可用性处理。

Android 14 起支持任意 alpha，但 Z-below 和 Z-above 的实现语义不同。默认 Z-below 时，半透明值调制的是 hole-punch；两个相互覆盖的 Z-below SurfaceView 不保证得到普通 View 那样的正确混合。复杂交叉透明、任意 shader mask 或把 Surface 内容当普通纹理参与宿主效果时，`TextureView` 往往更符合所需语义。

### 4.4 几何状态与内容状态分开

SurfaceView 的位置、缩放、crop、显隐、圆角和相对 Z-order 属于 `SurfaceControl.Transaction` 状态；视频帧、预览帧或游戏帧属于 BLAST layer 的 buffer 状态。两类状态可以在同一次 SurfaceFlinger transaction 中生效，也可能来自不同提交时刻。

Android 17 的硬件加速路径使用 `RenderNode.PositionUpdateListener` 从 RenderThread 获得 frame number 和最终位置。`applyOrMergeTransaction()` 再调用 `ViewRootImpl.mergeWithNextTransaction(transaction, frameNumber)`，把位置 transaction 与宿主目标帧合并。UI 线程触发的其它更新可通过 `ViewRootImpl.applyTransactionOnDraw()` 随下一次 draw 提交。

需要绑定到 SurfaceView 下一块内容 buffer 的 transaction，使用公开的 `applyTransactionToFrame()`。源码以 `mBlastBufferQueue.getLastAcquiredFrameNum() + 1` 计算目标 frame number，再调用 `mergeWithNextTransaction()`。公开 API 文档也规定了边界：连续渲染时无法严格定义它会绑定哪一帧；调用后没有新内容帧时，该 transaction 也可能不生效。它不是一个“立即显示下一帧”的阻塞承诺。

## 5. 版本演进：Android 12 到 Android 17

SurfaceView 的现代分析基线从 Android 12 开始。这个版本已经使用 `BLASTBufferQueue` 和 parent-child `SurfaceControl` 结构，适合与当前 trace 对照。每一版是否需要改变排查方法，取决于本文关注的对象：buffer 提交、生命周期、alpha、HDR、层级或视觉效果。

| 平台 | 与 SurfaceView 相关的关键变化 | 对 trace / 代码 Review 的影响 |
|---|---|---|
| Android 12 / API 31 | `SurfaceView` 已接入 `BLASTBufferQueue`；container、BLAST child、background layer 组成现代主线，几何 transaction 可与 ViewRoot 帧合并 | 从此应分别看 container 几何与 BLAST child buffer；旧式独立窗口模型不再适合作为主解释 |
| Android 13 / API 33 | 主体仍沿用 Android 12 的 BLAST 与 RenderNode 位置同步结构，没有需要改写本文主链路的公开 SurfaceView 架构变化 | 不应因为系统版本从 12 升到 13 就假设队列或 layer 拓扑改变；仍以设备 layer tree 和源码 tag 为证据 |
| Android 14 / API 34 | 支持任意 alpha；新增 `setSurfaceLifecycle()` 及 visibility/attachment 生命周期策略 | 半透明问题要区分 Z-below hole-punch 与 Z-above Surface alpha；Surface 是否在不可见期间保留，开始有公开策略可配置 |
| Android 15 / API 35 | 新增 `setDesiredHdrHeadroom()` | HDR SurfaceView 可独立表达所需 HDR/SDR headroom；最终可用范围仍受面板、环境、bit depth 和系统策略限制 |
| Android 16 / API 36 | 新增 `setCompositionOrder()` / `getCompositionOrder()`；公开层级控制从两个布尔式旧 API 扩展为整数 order | 多 SurfaceView 的相对层级可表达得更清楚；相同 order 仍未定义，迁移时不能机械替换而忽略正负值语义 |
| Android 17 / API 37 | 新增 `setBlurRegions()` / `getBlurRegions()`；当前源码把 blur region 与 RenderThread 位置、缩放、crop 一起换算，并维持 container + BLAST + background 结构 | blur 坐标相对 SurfaceView bounds，尺寸变化后需要更新；trace 仍要把视觉 blur transaction 与内容 buffer 分开 |

### Android 12：BLAST 成为分析起点

Android 12 tag 的 `SurfaceView.java` 已经导入并创建 `BLASTBufferQueue`，构造 BLAST layer，并通过 `ViewRootImpl.mergeWithNextTransaction()` 合并 RenderThread 位置 transaction。这里确立了当前最重要的两个边界：内容 buffer 归 BLAST child，位置与裁剪归 SurfaceControl transaction。

因此，Android 12 之后看到 SurfaceView 卡顿，不能只问“应用有没有 `queueBuffer()`”。还要看目标 child layer 是否获得新 buffer、对应 acquire fence 是否 ready、container 几何是否在同一显示周期生效。

### Android 13：主链路延续

Android 13 没有引入需要重画本文链路图的公开 SurfaceView 架构变化。这个结论很重要：版本演进不等于每个大版本都必须出现一条新机制。排查 Android 13 时，仍以 BLAST、RenderNode 位置同步、SurfaceHolder 生命周期和 HWC composition 为主。

如果 Android 12 与 13 设备表现不同，优先核对厂商 Composer HAL、gralloc、codec/camera pipeline、刷新率策略及 backport，而不是先假设 AOSP SurfaceView 主结构换代。

### Android 14：alpha 和生命周期成为公开能力

Android 14 的两个变化会直接改变应用行为。

第一，SurfaceView 支持任意 alpha。Z-above 时 alpha 直接作用于 Surface 内容；Z-below 时 alpha 作用于 hole-punch。两种情况在视觉上可能相近，在合成对象和重叠语义上并不相同。

第二，`setSurfaceLifecycle()` 提供三种常量：默认策略、跟随 visibility、跟随 attachment。默认策略等同于跟随 visibility。选择 attachment 策略可以让 SurfaceView 暂时不可见时仍保留 Surface，减少重建，但也会延长 buffer、Producer 连接和相关资源的生命周期。Review 时应检查业务是否同步停止不需要的生产工作。

### Android 15：SurfaceView 独立表达 HDR headroom

`setDesiredHdrHeadroom(float)` 用 HDR 白点相对 SDR 白点的比例表达期望值。`0.0f` 表示交给系统自动选择，合法非零值从 `1.0f` 开始。它是 SurfaceView 自己的请求，不应拿 Window 的 headroom 设置替代。

该 API 表达的是期望，不是硬件保证。分析 HDR 偏暗、亮度跳变或 composition type 变化时，要同时看 Surface dataspace、buffer bit depth、显示能力、系统亮度/环境策略与 HWC 支持。

### Android 16：整数 composition order

`setCompositionOrder(int)` 将“宿主上方或下方”与“多个 SurfaceView 之间谁更高”放到同一个整数模型里。负数位于宿主下方，非负数位于宿主上方，数值更大的 peer 位于更高层；相同数值的 peer 顺序未定义。

旧代码常把 `setZOrderMediaOverlay(true)` 理解成“到最上层”。它只是在仍低于宿主窗口的 SurfaceView 之间选择较高 sublayer。迁移到 composition order 时，应先写出需要的完整相对关系，再分配值。

### Android 17：blur region 与当前实现锚点

`setBlurRegions(Collection<BlurRegion>)` 在 API 37 公开。区域坐标相对 SurfaceView bounds；SurfaceView 尺寸改变后，调用方应更新区域。Android 17 源码在 RenderThread 位置回调里按 window offset、View scale 与 surface-to-node scale 更新 blur 和 crop，说明 blur 的正确位置依赖几何状态，而非内容 Producer 自己处理。

Android 17 当前 layer 树仍以 container、BLAST child 和 background color layer 为核心。文章后续所有类名、方法名和 transaction 边界均以 `android-17.0.0_r1` 为准。

### 旧版本兼容注

官方 `SurfaceView` 类文档至今仍提示：Android 7.0 之前，SurfaceView 位置相对 View 渲染可能异步，平移和缩放可能产生伪影。这个说明用于解释仍需支持古老设备的兼容问题，不进入 Android 12—17 的主时间线，也不能拿来解释现代 BLAST 设备上的每一次几何错位。

## 6. 生命周期：Producer 什么时候可以使用 Surface

Activity 可见、View 已创建和底层 `Surface` 有效是三个不同状态。Producer 能否提交 buffer，应以 `SurfaceHolder.Callback` 为准。

官方契约给出的硬边界是：

- `surfaceCreated()` 在 Surface 创建后调用，业务可以启动或连接渲染 Producer；
- `surfaceChanged()` 在格式或尺寸发生结构变化后调用，并且在 `surfaceCreated()` 之后至少调用一次；
- `surfaceDestroyed()` 在 Surface 销毁前调用。回调返回后，任何线程都不应再访问该 Surface；若渲染线程直接使用它，必须在回调返回前确保线程停止触碰 Surface。

这些回调运行在 SurfaceView 所在 window 的线程，通常是应用主线程。若 Producer 在工作线程或远端服务，回调必须与生产状态同步，不能只把 `Surface` 引用设为 null 就返回。

下面是生命周期顺序的应用侧骨架。`FrameProducer` 是应用自有接口，用来强调所有权，Android SDK 中没有这个类型。

```kotlin
private interface FrameProducer {
    fun attach(surface: Surface)
    fun resize(width: Int, height: Int, format: Int)
    fun detachAndWaitUntilIdle()
}

surfaceView.holder.addCallback(object : SurfaceHolder.Callback {
    override fun surfaceCreated(holder: SurfaceHolder) {
        frameProducer.attach(holder.surface)
    }

    override fun surfaceChanged(
        holder: SurfaceHolder,
        format: Int,
        width: Int,
        height: Int,
    ) {
        frameProducer.resize(width, height, format)
    }

    override fun surfaceDestroyed(holder: SurfaceHolder) {
        frameProducer.detachAndWaitUntilIdle()
    }
})
```

这段代码用应用自有接口表达 `surfaceDestroyed()` 的同步语义。对 EGL/Vulkan 线程，需要停止 swap/present 并释放或切换 native window；对 MediaCodec，需要停止向旧 output Surface 渲染或切换输出；对 Camera，需要完成 session/output configuration 的撤销。具体 API 因 Producer 而异。

### Android 17 内部怎样创建 Surface

下面是源码职责的概念骨架，不是可编译 Java，也省略了 flag、错误恢复、回调和锁。

```text
SurfaceView.updateSurface()
  determine visibility / size / format / parent / lifecycle changes
  createBlastSurfaceControls() when controls are absent
    create container SurfaceControl under ViewRoot bounds layer
    create BLAST child SurfaceControl under container
    create background color layer under container
    create or recreate BLASTBufferQueue
    update BLASTBufferQueue with child, width, height, format
  copySurface()
    mSurface.copyFrom(mBlastBufferQueue)
  apply or merge geometry transaction
  dispatch surfaceCreated / surfaceChanged / surfaceRedrawNeeded
```

这份骨架用于定位 `updateSurface()` 的职责。创建 BLAST 对象、更新 Java `Surface`、提交几何和派发生命周期回调都在同一大方法周围完成，但它们不是同一时刻完成的单个原子操作。trace 中要按实际 transaction、Producer connect 与首个 buffer 分开对齐。

### 常见生命周期错误

- 用 `onResume()` 直接判断 Surface 一定可用：Activity 已恢复时，Surface 回调可能尚未到来。
- 用 `onPause()` 判断 Surface 一定销毁：Android 14 的 attachment 生命周期策略可能保留 Surface。
- `surfaceDestroyed()` 只发异步 stop 消息后立即返回：渲染线程可能继续向即将失效的 Surface 提交。
- 尺寸变化只更新 View，不通知 Producer：Producer buffer 尺寸、container crop 和显示缩放可能暂时不一致。
- 重建后继续复用旧 EGLSurface、ANativeWindow 或 codec output 引用：Java `Surface` 对象外观相似，不代表 native producer connection 未变化。

## 7. 起跑节奏：宿主帧和内容帧由谁驱动

### 7.1 宿主窗口

宿主窗口通常由 `Choreographer` 的 `vsync-app` 预测回调驱动。输入改变控制条位置、动画更新遮罩、Traversal 重新布局 SurfaceView，都会形成宿主帧。宿主 HWUI buffer 包含普通 View 和 hole-punch 结果，不包含 SurfaceView 的主体像素。

宿主窗口慢时，可能出现：

- 控制条、字幕或按钮晚更新；
- SurfaceView container 的位置/crop transaction 晚提交；
- 默认 Z-below 的 hole-punch 仍处于旧位置；
- 宿主 buffer 与已经到达的新内容帧在一轮合成中错位。

### 7.2 独立 Producer

内容 Producer 不必等待宿主 `doFrame()`：

| 内容来源 | 可能参与生产的进程 / 线程 | 优先观察 |
|---|---|---|
| MediaCodec / Codec2 | 应用控制线程、`media.codec` / `media.swcodec`、Codec2 vendor service、厂商组件 | output buffer 时间、render timestamp、目标 Surface 的 queue、protected/HDR 属性 |
| Camera 预览 | 应用 camera 线程、`cameraserver`、camera provider/HAL、厂商进程 | capture result、preview stream、HAL fence、目标 Surface queue |
| EGL / Vulkan / 游戏引擎 | 应用或引擎进程内的渲染线程，GPU driver 工作队列 | CPU frame、EGL swap/Vulkan present、GPU completion fence、queue backpressure |

表中列的是常见位置，不是进程名契约。不同设备会采用不同 codec service、camera provider 和 vendor 进程。确认 Producer 的可靠方法是沿目标 BufferQueue 的 connect、dequeue、queue 与 fence 回溯，而不是按进程名猜测。

### 7.3 帧率不一致是正常状态

宿主可能运行在 60、90 或 120 Hz，视频可能是 24/30 fps，相机节奏受 sensor exposure 和 stream configuration 影响，游戏还会受 frame pacing 与 GPU 负载影响。SurfaceFlinger 每轮显示可以复用某个 layer 的上一块 buffer，所以“宿主有新帧、视频没有新帧”本身不是故障。

需要排查的是：

- 新内容帧是否在期望显示时间前进入 SurfaceFlinger；
- 复用旧 buffer 是内容帧率设计，还是 Producer 迟到；
- 宿主几何和 hole-punch 是否对应当前要显示的内容；
- HWC strategy 是否因为 layer 条件变化产生额外 client composition 或拒绝 protected 路径。

## 8. 汇合过程：buffer、几何、fence 和 HWC

### 8.1 两套 BufferQueue 不共享背压

宿主窗口与 SurfaceView 内容各自有队列和 release channel。宿主 RenderThread 在 `dequeueBuffer()` 等待，说明宿主队列暂时没有可写 slot；它不能证明 SurfaceView 内容队列也堵塞。反过来，codec 或游戏 Producer 被独立队列背压时，宿主按钮仍可能流畅更新。

Producer/Consumer 的通用循环如下。这是概念模型，不代表 MediaCodec、Camera、EGL 和 Vulkan 使用相同 API 名。

```text
Producer                               Consumer / SurfaceFlinger side
dequeueBuffer()  <--- free slot
fill buffer
queueBuffer(buffer, completion fence) ---> acquireBuffer()
                                         wait before reading when required
                                         composite / present
dequeue or reuse waits <--- releaseBuffer(release fence)
```

BufferQueue 传递 buffer handle，不复制整块像素。队列长度、可 dequeue 数量和丢帧模式由 Producer、Consumer 和配置共同决定，不能用固定的“三缓冲”假设解释所有 SurfaceView。

### 8.2 BLAST 怎样把 buffer 变成 transaction

Android 17 的 `BLASTBufferQueue::acquireNextBufferLocked()` 从 Consumer 侧取得 `BufferItem`，把 buffer、acquire fence、frame number、dataspace、HDR metadata、crop、transform 等状态写入 `SurfaceComposerClient::Transaction`。trace 中的 buffer transaction 对应这一类提交，但具体 slice/counter 名会随 tracing 配置和实现变化。

`mergeWithNextTransaction()` 按 frame number 保存外部 transaction；取得对应 buffer 后，`mergePendingTransactions()` 把它并入 buffer transaction。这个机制能把调用方指定的 SurfaceControl 状态与某块内容 buffer 放进同一 transaction 边界，但不能让外部 Producer 提前生成 buffer。

### 8.3 acquire fence：提交不等于可读

Producer 把 GPU、codec、camera 或 blitter 的完成 fence 随 buffer 提交。站在 SurfaceFlinger 这一侧，该 fence 是 acquire fence：在硬件写入完成前，Consumer 不能安全读取 buffer。

普通路径会在满足 transaction/latch 规则的前提下等待 fence ready。Android 还存在 latch unsignaled buffer 的优化：当设备配置与 transaction 条件允许时，SurfaceFlinger 可以先采纳 buffer 状态，把实际 fence wait 推迟到更接近合成读取的位置。这个优化没有消除依赖，也不适用于所有 transaction；看到“已 latch”不能直接写成“GPU/codec 已完成”。

kernel 侧，sync file 把一个 fence 作为 fd 暴露给用户空间，dma-fence 表示跨驱动/硬件工作的依赖。Perfetto 的 `sync_wait`、fence timeline 或驱动事件只能说明等待关系的一部分；要定位 fence 由谁创建，仍需结合 Producer、GPU、codec、camera 与 HWC 轨迹。

### 8.4 几何与 buffer 的三种对齐方式

1. **与宿主帧对齐**：RenderThread 位置回调携带宿主 frame number，`ViewRootImpl.mergeWithNextTransaction()` 合并 container 的位置、scale、crop、show/hide。
2. **与 ViewRoot 下一次 draw 对齐**：UI 线程更新通过 `applyTransactionOnDraw()` 合并到 ViewRoot draw transaction。
3. **与 SurfaceView 下一块内容 buffer 对齐**：`applyTransactionToFrame()` 把外部 transaction 交给 SurfaceView 的 BLAST 队列。

三者服务的目标不同。移动 SurfaceView 时，位置通常应跟宿主渲染帧；修改一个必须与新视频帧同时生效的 child SurfaceControl 状态时，才需要考虑内容 frame transaction。把所有 transaction 都强行绑到内容下一帧，可能在低帧率视频或 Producer 停止时延迟生效。

### 8.5 SurfaceFlinger 的 layer 状态

Android 17 不宜再用下面这种旧式伪调用栈描述：`SurfaceFlinger::commit()` 逐个调用 `Layer::latchBuffer()`，随后直接进入 `composite()`。当前 FrontEnd 会先消费 transactions，更新 `RequestedLayerState`，生成或更新 `LayerSnapshot`；后续再由 composition/latch 相关阶段处理 buffer 与 output 状态。

用于读 trace 的职责骨架如下：

```text
SurfaceFlinger transaction processing
  receive host and SurfaceView transactions
  update RequestedLayerState
  update LayerSnapshot / hierarchy / visibility
  逐个 buffer layer 判断可用性与 latch 状态

CompositionEngine / Output
  build visible layer list for display
  negotiate HWC composition strategy
  run RenderEngine for CLIENT layers when needed
  present and collect present / release fences
```

该骨架解释了为什么同一 SurfaceView container 的几何 transaction 与 BLAST child 的 buffer transaction 要分别观察。FrontEnd 已接收新几何时，buffer layer 仍可能沿用旧内容；也可能新内容到达，而宿主 hole-punch 或 container 几何还未更新。

### 8.6 HWC：独立 layer 只是获得单独评估机会

SurfaceView 经常用于视频和相机，因此容易走 device composition，但“SurfaceView 必定 overlay”是错误结论。HWC 会结合整屏 layer 集合与设备能力判断：

- buffer format、modifier、usage 与 dataspace；
- crop、缩放、旋转、alpha 与 blending；
- HDR metadata、目标颜色模式与显示能力；
- protected/secure 要求；
- 可用 plane、bandwidth、scaler 及厂商限制；
- 其它 layer 同时占用的资源。

普通非 protected layer 不满足 device composition 条件时，可以被改为 CLIENT，由 RenderEngine 合成进 client target。protected buffer 必须保持硬件保护链路；公共 AOSP 文档以 protected overlay 路径解释 DRM 视频，设备若无法建立合规路径，常见结果是黑屏、拒绝显示或播放失败，不能把它当普通 RGBA layer 随意回退到非保护 GPU 合成。

Android 17 的 `HWComposer::getDeviceCompositionChanges()` 支持两类流程：允许 skip validate 时调用 `presentOrValidateDisplay()`；返回 `PresentSucceeded` 代表这次组合调用已执行 present 并保存 fences，返回 `Validated` 才继续读取 changed composition/requests 并接受变化。不允许 skip validate 时走 `validateDisplay()`。无论哪条路径，不能从函数名推断 panel 已经完成扫描。

### 8.7 present fence 与 release fence

- **present fence**：描述本次 display present 工作的完成边界，signal 时间用于 Android 显示栈时序和调度反馈；它不是光学测量。
- **per-layer release fence**：描述 HWC 不再读取对应 layer buffer 的时间；SurfaceFlinger/BLAST/BufferQueue 把它送回各自 Producer，用于安全复用。
- **client target fence**：RenderEngine 输出 client target 后，交给 HWC 的 acquire fence；它与某个 SurfaceView 原始 buffer 的 acquire/release fence 不是同一个对象。

宿主和 SurfaceView 各有 release channel。若 SurfaceView Producer 等 release fence，先找对应 child layer；不要拿宿主窗口的 release 轨迹解释独立队列背压。

## 9. 源码入口：Android 17 应该跟读哪里

### Platform：`android-17.0.0_r1`

| 核查点 | 一手来源 | 用来确认什么 |
|---|---|---|
| SurfaceView 公开语义 | [Android `SurfaceView` reference](https://developer.android.com/reference/android/view/SurfaceView) | Android 14 alpha/lifecycle、Android 15 HDR headroom、Android 16 composition order、Android 17 blur region 的公开契约 |
| 生命周期回调 | [Android `SurfaceHolder.Callback` reference](https://developer.android.com/reference/android/view/SurfaceHolder.Callback) | Surface 有效区间、线程停止责任、尺寸/格式变化语义 |
| Android 17 SurfaceView 实现 | [AOSP `SurfaceView.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/core/java/android/view/SurfaceView.java) | hole-punch、container/BLAST/background 创建、生命周期、位置回调、transaction 合并、blur |
| BLAST transaction | [AOSP `BLASTBufferQueue.cpp`](https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-17.0.0_r1/libs/gui/BLASTBufferQueue.cpp) | `acquireNextBufferLocked()`、`mergeWithNextTransaction()`、`mergePendingTransactions()`、release callback |
| Transaction 数据模型 | [AOSP `SurfaceComposerClient.cpp`](https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-17.0.0_r1/libs/gui/SurfaceComposerClient.cpp) | Java/native transaction 最终承载的 layer 状态与 buffer 状态 |
| SurfaceFlinger FrontEnd | [AOSP `SurfaceFlinger.cpp`](https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-17.0.0_r1/services/surfaceflinger/SurfaceFlinger.cpp)、[AOSP FrontEnd](https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-17.0.0_r1/services/surfaceflinger/FrontEnd/) | transaction 消费、RequestedLayerState、LayerSnapshot 与 hierarchy 更新 |
| HWC strategy / present | [AOSP `HWComposer.cpp`](https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-17.0.0_r1/services/surfaceflinger/DisplayHardware/HWComposer.cpp)、[HWC composition operations](https://source.android.com/docs/core/graphics/implement-hwc#display_comp_ops) | validate、presentOrValidate、client target、present/release fence |
| BufferQueue / protected buffer | [AOSP BufferQueue and Gralloc](https://source.android.com/docs/core/graphics/arch-bq-gralloc) | Producer/Consumer 循环、handle 传递、SurfaceView 视频队列、保护路径 |
| FrameTimeline 支持边界 | [Perfetto FrameTimeline](https://perfetto.dev/docs/data-sources/frametimeline) | SurfaceView 当前不受完整支持，不能只靠 app FrameTimeline 还原主体内容 |

`SurfaceView.java` 建议按这个顺序阅读：

1. 类注释：默认 Z-below、hole-punch、回调线程、Android 7 兼容注、Android 14 alpha；
2. `gatherTransparentRegion()`、`draw()`、`dispatchDraw()`、`clearSurfaceViewPort()`：宿主怎样露出下方内容；
3. `updateSurface()` 与 `performSurfaceTransaction()`：什么状态变化触发创建、更新和回调；
4. `createBlastSurfaceControls()`：三类 SurfaceControl 与 BLASTBufferQueue；
5. `SurfaceViewPositionUpdateListener` 与 `applyOrMergeTransaction()`：RenderThread 几何怎样绑定宿主 frame number；
6. `applyTransactionToFrame()`：内容下一帧 transaction 的公开边界。

### Kernel：`android17-6.18-2026-06_r6`

本文进入 kernel 的部分只用于解释 fence fd 和驱动同步原语：

- [`drivers/dma-buf/sync_file.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/drivers/dma-buf/sync_file.c)：sync file 如何把 fence 暴露为 fd；
- [`drivers/dma-buf/dma-fence.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/drivers/dma-buf/dma-fence.c)：dma-fence 的 signal、callback 与 wait 基础语义。

这两个文件不能解释某台设备的 codec、GPU、camera 或 DPU 为什么在某时刻 signal。创建 fence 的具体驱动、vendor HAL 与硬件队列仍需设备源码或 trace。

### 版本演进的一手锚点

- [Android 12 `SurfaceView.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-12.0.0_r1/core/java/android/view/SurfaceView.java)：BLAST 基线；
- [Android 13 `SurfaceView.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-13.0.0_r1/core/java/android/view/SurfaceView.java)：主链路延续；
- [Android 14 `SurfaceView.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-14.0.0_r1/core/java/android/view/SurfaceView.java)：alpha 与 lifecycle；
- [Android 15 `SurfaceView.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-15.0.0_r1/core/java/android/view/SurfaceView.java)：HDR headroom；
- [Android 16 `SurfaceView.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-16.0.0_r1/core/java/android/view/SurfaceView.java)：composition order；
- [Android 17 `SurfaceView.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/core/java/android/view/SurfaceView.java)：blur region 与本文当前实现。

## 10. Perfetto 证据链：怎样复原一帧

### 10.1 采集前先确认数据源

至少需要能够观察：

- app `gfx` / `view` atrace 与调度；
- SurfaceFlinger、layer、transactions、FrameTimeline；
- ftrace 中的 sched、fence/sync 相关事件；
- GPU、camera、codec、binder 或 vendor 数据源，按故障场景增加；
- HWC composition type 或 layer trace，设备支持时开启。

Perfetto 官方 FrameTimeline 文档明确写着 SurfaceView 当前不受完整支持。因此，不能把“SurfaceView 没有独立 app FrameTimeline slice”当成没有新内容帧。SurfaceView 主体应优先用 layer trace、目标 BufferQueue/BLAST、Producer queue、acquire fence、SurfaceFlinger latch 与 present 证据复原；宿主窗口和 SurfaceFlinger 的 FrameTimeline 仍有参考价值。

### 10.2 第一步：建立 layer 身份表

先从 layer tree 或 trace packet 记录这些对象：

| 对象 | 应记录字段 | 目的 |
|---|---|---|
| 宿主 App Window layer | layer id、name、parent、buffer layer id | 对齐宿主 HWUI buffer 与 SurfaceFlinger 状态 |
| SurfaceView container | layer id、name、parent、relative-Z、crop/position | 对齐 View 几何和层级 |
| SurfaceView BLAST child | layer id、name、parent、buffer size、dataspace、composition type | 对齐主体内容 buffer |
| background / embedded child | layer id、parent、visible region | 避免把辅助层当主体 buffer |

Android 17 `SurfaceView.setTag()` 生成的 Java tag 形如 `SV[<identityHash> <windowShortName>]`，`createBlastSurfaceControls()` 再用传入 name 和 `name + "(BLAST)"` 创建 layer。最终 trace 名还可能带 SurfaceFlinger 分配的序号或事务前缀。不要依赖一条硬编码的 `SurfaceView[package/activity]#id` 正则；用 parent-child 关系、buffer 属性和 Producer 连接共同确认。

### 10.3 第二步：把两条生产线分组

宿主组关注：

- `Choreographer#doFrame` 及 Input/Animation/Traversal；
- `syncAndDrawFrame`、RenderThread、GPU work；
- 宿主 BLAST `dequeueBuffer` / queue 与 `BufferTX - <hostLayerName>`；
- SurfaceView position/crop transaction 和宿主 hole-punch 对应的 draw。

主体组关注：

- Producer 的工作线程或服务；
- 目标 Surface 的 connect/dequeue/queue；
- BLAST child 的 `BufferTX - <surfaceViewLayerName>`；
- buffer acquire fence、frame number、dataspace、transform、crop；
- 对应 layer 的 release fence 回传。

两组的时间轴不要用“同一列第 N 帧”机械配对。视频 30 fps、宿主 120 Hz 时，多个宿主帧复用同一个视频 buffer 是正常行为。应用应使用 frame number、transaction id、layer id、fence 和目标 present 周期建立关系。

### 10.4 第三步：检查几何与内容是否同周期生效

发生滑动、旋转、resize、进入画中画前后，记录：

1. 宿主 Traversal 何时计算出新 bounds；
2. `PositionUpdateListener` 对应的 frame number；
3. container position/matrix/crop transaction 何时进入 SurfaceFlinger；
4. hole-punch 所在宿主 buffer 何时提交；
5. BLAST child 新 buffer 何时到达、acquire fence 何时 signal；
6. 哪个 display present 同时采用了新宿主 buffer、新几何和新内容。

三者不齐时，画面可能出现不同组合：

- 新 hole-punch + 旧 container 几何：露出错误区域；
- 新 container 几何 + 旧内容 buffer：内容位置正确但画面时刻旧；
- 新内容 + 旧宿主遮罩：视频已更新，控制层仍是上一帧；
- 新几何 transaction 等下一块低帧率内容 buffer：整体位置变化延迟。

### 10.5 第四步：解释 fence wait

看到 fence wait 时依次确认：

1. 等待发生在哪个进程、线程和 layer；
2. fence 是该 buffer 的 acquire、client target acquire、HWC release，还是 present fence；
3. 上游可能是 GPU、codec、camera、blitter、RenderEngine 还是 display；
4. wait 是否越过目标 deadline；
5. 同一期间 CPU 线程是 running、runnable 还是 blocked。

“等待 fence”只描述依赖，没有自动给出责任模块。GPU completion fence 迟到与 HWC release fence 迟到都会让 Producer 后续受阻，但修复方向完全不同。

### 10.6 第五步：检查 HWC strategy

对每个 display frame，记录 SurfaceView BLAST child 的 composition type。发生 DEVICE→CLIENT、CLIENT→DEVICE、protected layer 消失或 client target 成本突增时，对照以下状态变化：

- alpha、crop、rotation、scale；
- dataspace、HDR metadata、buffer format/usage；
- 同屏 layer 数量与其它 overlay 占用；
- secure/protected flag 与外接显示状态；
- display mode、refresh rate 与分辨率；
- vendor Composer/HWC error 或 fallback 日志。

composition type 变化是结果。没有 vendor capability 和整屏 layer 条件，不能仅凭 YUV/RGBA 或 SurfaceView 类型断定原因。

### 10.7 一次可复用的排查顺序

1. 用 layer tree 证明宿主、container、BLAST child 的关系；
2. 用 SurfaceHolder 回调和 Producer connect 确认生命周期；
3. 分别标出宿主 buffer 与主体 buffer 的提交；
4. 对齐 container 几何、宿主 hole-punch 和主体 buffer；
5. 识别 acquire/release/present fence 的所有者；
6. 检查 SurfaceFlinger 是否复用旧 buffer 或推迟 transaction；
7. 检查 HWC composition type 和 client target；
8. 把目标 display present 与用户看到的异常帧对应起来。

这个顺序能避免两个高频错误：把宿主 RenderThread 的耗时当成视频/相机 Producer 耗时，以及把 SurfaceView 的独立队列背压归因到宿主窗口 buffer。

## 11. 类型边界：与标准窗口、TextureView 和混合出图区分

### 11.1 与标准窗口

标准 HWUI 窗口的主要可见内容被绘制进宿主 App Window buffer，SurfaceFlinger 主要接收该窗口的 buffer layer。SurfaceView 页面仍有宿主窗口，但主体内容另有 BLAST child buffer layer。

区分点不是“有没有 RenderThread”，因为 SurfaceView 页面同样有宿主 RenderThread；区分点是主体像素是否进入宿主最终 buffer。

### 11.2 与 TextureView

TextureView 的 Producer 也向 BufferQueue 交 buffer，但应用侧 `SurfaceTexture`/GL consumer 将其作为纹理交给宿主 HWUI 绘制。最终显示的主体像素进入宿主窗口 buffer，SurfaceFlinger 通常不把它当一个独立可见 SurfaceView child layer。

这带来两组差异：

| 维度 | SurfaceView | TextureView |
|---|---|---|
| 最终可见 layer | 主体是独立 buffer layer | 主体通常进入宿主窗口 layer |
| 变换与混合 | 受 SurfaceControl、Z-order 和 hole-punch 语义约束 | 可作为 View/纹理参与宿主变换与 alpha |
| 额外采样 | 有机会避免宿主再次采样 | 通常需要宿主对纹理采样并绘制 |
| HWC 机会 | 主体可被独立评估 DEVICE/CLIENT | HWC 主要看到合成后的宿主窗口 |
| trace 重点 | 两套 buffer + 几何同步 | Producer buffer + 宿主消费/绘制 |

### 11.3 与混合出图

一个页面可以同时包含多个 SurfaceView、TextureView、WebView、普通 HWUI、弹窗或嵌入式 SurfaceControlViewHost。只要存在 SurfaceView，仍可用本文方法分析它的独立子树；但整页性能不能归结为单个 SurfaceView 类型。

混合出图需要给每个可见 layer 建立生产者、消费者、几何所有者和合成方式映射。某个视频 layer 走 DEVICE，不代表同屏 WebView、模糊遮罩或窗口动画也走 DEVICE。

### 11.4 与 Camera、Video Overlay、Game 文章的关系

Camera、视频和游戏是业务/Producer 类型，SurfaceView 是承载方式。Camera 可以输出到 SurfaceView、TextureView 或 ImageReader；游戏可以使用普通窗口 Surface，也可以嵌入 SurfaceView；视频是否最终得到 overlay 由 HWC strategy 决定。

因此，看到 Camera 或 MediaCodec 不能直接把问题定为 SurfaceView，看到 SurfaceView 也不能直接把问题定为 overlay。先确认承载拓扑，再进入对应 Producer 的专项链路。

## 12. 故障模式：从现象回到责任对象

| 现象 | 首要假设 | 必查证据 | 不应直接下的结论 |
|---|---|---|---|
| 控制条卡，视频流畅 | 宿主 main/RenderThread/宿主 buffer 慢 | doFrame、Traversal、host BufferTX、host GPU | codec 正常就说明整页正常 |
| 视频卡，按钮流畅 | 内容 Producer、独立队列或 acquire fence 迟到 | producer queue、SV BufferTX、codec/camera/GPU fence | 宿主 main 空闲所以系统没有问题 |
| 滑动时视频错位一帧 | container 几何、hole-punch 与内容 buffer 未对齐 | PositionUpdateListener frame number、host buffer、SV child latch | Android 7 以前的异步窗口问题在现代设备复现 |
| 首帧黑屏 | 生命周期、Producer connect、首 buffer、background/visibility | surfaceCreated/Changed、connect、first queue、show transaction | `surfaceCreated()` 到了就一定已有可显示帧 |
| 前后台切换后旧帧或崩溃 | 旧 Surface 仍被线程访问或 Producer 切换不完整 | surfaceDestroyed 返回前后的 queue、EGL/codec/camera 状态 | Activity 生命周期能替代 Surface 生命周期 |
| protected 视频黑屏 | 保护链路或外接显示能力不满足 | protected/secure flag、HWC composition、HDCP/display 状态、vendor error | 让普通 GPU client composition 回退即可 |
| 功耗突然升高 | DEVICE→CLIENT 或 client target 面积/帧率增加 | per-layer composition type、RenderEngine、GPU、display mode | SurfaceView 天生低功耗 |
| Producer `dequeueBuffer()` 长 | 独立队列没有可复用 slot 或 release fence 未回 | 对应 layer release fence、queued/acquired 状态 | 一定是 CPU 调度慢 |
| alpha 动画重叠异常 | Z-below alpha 调制 hole-punch，或多个 peer order 关系不完整 | composition order、host hole-punch、layer alpha | SurfaceView alpha 等同普通 View alpha |
| blur 区域偏移 | API 37 blur 坐标未随 bounds 更新，或几何 transaction 未同步 | blur region、SurfaceView bounds、scale/crop、position callback | Producer buffer 自己画错了 blur |

### Review 时必须回答的十个问题

1. 主体内容是否落在独立 BLAST child layer？
2. 谁持有 Producer，buffer 填充发生在哪个线程或服务？
3. `Surface` 的有效期由哪套 callback 和 lifecycle strategy 控制？
4. 宿主窗口 buffer 包含哪些 UI，hole-punch 在哪里形成？
5. SurfaceView container 的 parent、crop、position 和 composition order 是什么？
6. 新几何跟宿主 frame 对齐，还是被绑定到下一块内容 buffer？
7. acquire fence、release fence 和 present fence 分别属于谁？
8. SurfaceFlinger 本轮采用新 buffer 还是复用旧 buffer？
9. HWC 把主体 layer 判为 DEVICE 还是 CLIENT，变化前后有哪些 layer 条件不同？
10. 用户看到的异常对应哪个 display present，而不是哪个 CPU slice 的结束？

这十个问题都有 trace 或源码答案后，SurfaceView 问题才能从“画面像是慢一帧”收敛到可修复的责任边界。

## 总结

SurfaceView 页面的核心结构是两条独立生产线：宿主窗口由 Choreographer、主线程和 RenderThread 生成普通 View buffer；主体内容由 codec、camera、EGL/Vulkan 或其它 Producer 向 SurfaceView 的独立 BLAST layer 提交 buffer。SurfaceFlinger 依据每个 layer 的 transaction、snapshot、buffer 和 fence 状态完成组合，HWC 再决定 DEVICE 或 CLIENT composition。

Android 17 的分析要分清 container 几何、BLAST child buffer、宿主 hole-punch 和 HWC composition 四个对象。生命周期以 `SurfaceHolder.Callback` 为边界，几何同步要区分宿主 frame transaction 与内容下一帧 transaction，fence fd 返回也不代表 fence 已 signal。Perfetto 的 FrameTimeline 对 SurfaceView 主体不提供完整支持，layer/BufferQueue/Producer/fence 证据必须补齐。

版本上，Android 12 是现代 BLAST 基线；Android 14 增加 alpha 与 lifecycle，Android 15 增加 HDR headroom，Android 16 增加 composition order，Android 17 增加 blur region。面对任一版本，先用该版本 tag 和设备 layer tree 确认对象，再用同一条证据链复原异常帧。

GENERATED FILE - DO NOT EDIT.
Source: docs/rendering_pipelines/S04_textureview_type.md
Source SHA-256: 2eff31edccc57811d6795c873ec59411e167b8344a538629ee1db77e5a8e4ce5

# Android Perfetto 系列 - App 出图类型 - TextureView 类型

`TextureView` 接收外部 Producer 的 buffer，但不会把这条 buffer stream 直接交给 SurfaceFlinger 显示。宿主 RenderThread 先消费 `SurfaceTexture` 中的最新 buffer，把它当纹理采样进 App Window buffer；SurfaceFlinger 最终看到的是宿主窗口 layer。

这条路径有两次生产：外部 Producer 生成内容 buffer，宿主 HWUI 再生成窗口 buffer。任意一次迟到、fence 等待或队列背压，都可能让用户看到旧内容或整窗晚一帧。

<!--more-->

## 阅读导航

### 本文目录

- 阅读说明
- 1. 一帧完整流程：外部 buffer 怎样进入宿主窗口
- 2. 类型判定：怎样证明页面使用 TextureView 路径
- 3. 选择原因：为什么接受一次宿主采样
- 4. 系统结构：SurfaceTexture、TextureLayer 与 App Window
- 5. 生命周期：SurfaceTexture 的可用期和所有权
- 6. 调度与消费：onFrameAvailable 怎样触发宿主帧
- 7. 版本演进：Android 12 到 Android 17
- 8. 同步与成本：两套队列、三类 fence、一次宿主 GPU 采样
- 9. 源码入口：Android 17 应该跟读哪里
- 10. Perfetto 证据链：按两次生产复原一帧
- 11. 类型边界与故障模式
- 总结

### 系列文章目录

1. [Android Perfetto 系列 - App 出图类型 - 总览与识别方法](S01_rendering_types_overview.md)
2. [Android Perfetto 系列 - App 出图类型 - AOSP 标准类型](S02_aosp_standard_type.md)
3. [Android Perfetto 系列 - App 出图类型 - SurfaceView 类型](S03_surfaceview_type.md)
4. [Android Perfetto 系列 - App 出图类型 - TextureView 类型](S04_textureview_type.md)
5. [Android Perfetto 系列 - App 出图类型 - 混合出图类型](S05_mixed_rendering_type.md)
6. [Android Perfetto 系列 - App 出图类型 - 多窗口类型](S06_multi_window_type.md)
7. [Android Perfetto 系列 - App 出图类型 - Software / 离屏类型](S07_software_offscreen_type.md)
8. [Android Perfetto 系列 - App 出图类型 - Native Graphics 类型](S08_native_graphics_type.md)
9. [Android Perfetto 系列 - App 出图类型 - WebView 类型](S09_webview_type.md)
10. [Android Perfetto 系列 - App 出图类型 - Flutter 类型](S10_flutter_type.md)
11. [Android Perfetto 系列 - App 出图类型 - Camera 类型](S11_camera_type.md)
12. [Android Perfetto 系列 - App 出图类型 - Video Overlay / HWC 类型](S12_video_overlay_hwc_type.md)
13. [Android Perfetto 系列 - App 出图类型 - Game 类型](S13_game_type.md)
14. [Android Perfetto 系列 - App 出图类型 - React Native 类型](S14_react_native_type.md)

## 阅读说明

平台源码固定到 Android 17 / API 37 的 `android-17.0.0_r1`，kernel 源码固定到 `android17-6.18-2026-06_r6`。`TextureView`、`SurfaceTexture`、HWUI `TextureLayer` / `DeferredLayerUpdater`、宿主 BLAST、SurfaceFlinger 与 HWC 的类名和调用名按平台 tag 核查；sync file 与 dma-fence 的底层语义按指定 kernel tag 核查。

MediaCodec、Camera、Web/地图引擎、GPU driver、gralloc 与 vendor Composer 的具体实现会因设备而变。正文只把 AOSP 能确认的 Consumer 和宿主显示边界固定下来，Producer 所在进程、buffer format、硬件等待与颜色处理必须用目标设备证据确认。

版本演进以 Android 12 为起点。Android 12 的 HWUI 已经使用 `ASurfaceTexture_dequeueBuffer()`、`AHardwareBuffer` 和 `SkImage` 消费 TextureView 内容，所以不能把这条路径写成 Android 17 新增；Android 17 是本文当前源码锚点。

## 1. 一帧完整流程：外部 buffer 怎样进入宿主窗口

以 Camera 预览 TextureView 上叠加普通 View 对焦框为例，一次可见更新包括下面 12 步：

1. Camera、codec、EGL/Vulkan 或其它外部 Producer 按自己的节奏取得可写 buffer。
2. Producer 填充内容，并把 buffer 与完成 fence 提交给 `SurfaceTexture` 背后的 BufferQueue。完成 fence 在应用侧 Consumer 看来是 acquire fence。
3. BufferQueue 通知 `SurfaceTexture.OnFrameAvailableListener`。Android 17 的 `TextureView` 把 listener 投递到 `mAttachInfo.mHandler`，也就是宿主 ViewRoot 所在线程。
4. listener 调用 `updateLayer()` 和 `invalidate()`。前者设置 TextureLayer 待更新标记，后者把宿主 View 标脏；已有 traversal/frame 时请求会被合并，没有 pending frame 时才继续申请新的 `vsync-app`。
5. 宿主主线程进入 `Choreographer#doFrame()`，按 `INPUT → ANIMATION → INSETS_ANIMATION → TRAVERSAL → COMMIT` 整理 View 树。
6. `TextureView.draw()` 在硬件加速 Canvas 上调用 `applyUpdate()`。它执行 `TextureLayer.prepare()`、`TextureLayer.updateSurfaceTexture()`，并由 `HardwareRenderer.pushLayerUpdate()` 把 native updater 放进 RenderThread 的 pending layer updates。
7. `onSurfaceTextureUpdated()` 在这次 UI 线程 `applyUpdate()` 之后调用。此时只完成了更新请求记录，RenderThread 尚不一定已经取得新 buffer。
8. UI 线程通过 `syncAndDrawFrame()` 把宿主树状态交给 RenderThread。`DrawFrameTask::syncFrameState()` 先处理 pending layer updates；`DeferredLayerUpdater::apply()` 调用 `ASurfaceTexture_dequeueBuffer()` 取得最新 `AHardwareBuffer`、dataspace、transform、crop、HDR metadata 与 fence 信息。
9. Android 17 源码明确让 `ASurfaceTexture_dequeueBuffer()` 丢弃除最新一帧外的 pending frame。RenderThread 将取得的 buffer 转为 Skia 可采样 `SkImage`，再把 TextureView 内容、对焦框和其它 View 一起画进 App Window buffer。
10. 宿主 RenderThread 将窗口 buffer 和自己的完成 fence 提交给 App Window BLAST。SurfaceFlinger server 收到的是宿主 layer 的 buffer transaction，TextureView 输入流没有成为一个独立可见 SF layer。
11. SurfaceFlinger 对宿主 layer 完成 transaction readiness、snapshot/latch 与 composition 准备。HWC 只能对整个宿主 layer 选择 DEVICE 或 CLIENT，不能把已栅格化进窗口 buffer 的 TextureView 区域单独交给 overlay plane。
12. validate/present 流程产生 present fence 和宿主 layer release fence。外部 SurfaceTexture 队列还有自己的 release fence 与 slot 回收；两套 release channel 分别约束外部 Producer 和宿主窗口 Producer。

### 显示链路图

这张图用来区分外部 Producer 的首次提交、宿主 HWUI 的纹理消费和 App Window 的第二次提交。

```mermaid
sequenceDiagram
    participant P as "External Producer"
    participant ST as "SurfaceTexture / BufferQueue"
    participant UI as "Host main / TextureView"
    participant RT as "Host RenderThread / HWUI"
    participant SF as "SF FrontEnd / CompositionEngine"
    participant HWC as "HWComposer / Composer HAL"
    participant DD as "Display driver"

    P->>ST: dequeueBuffer
    P->>P: codec / camera / EGL / Vulkan fills buffer
    P->>ST: queueBuffer(buffer + completion fence)
    ST-->>UI: onFrameAvailable on ViewRoot handler
    UI->>UI: updateLayer + invalidate
    SF-->>UI: vsync-app prediction callback when a new frame is needed
    UI->>UI: doFrame: INPUT → ANIMATION → INSETS → TRAVERSAL → COMMIT
    UI->>UI: TextureView.draw → applyUpdate
    UI->>RT: syncAndDrawFrame + pending TextureLayer update
    RT->>ST: ASurfaceTexture_dequeueBuffer(latest buffer)
    ST-->>RT: AHardwareBuffer + dataspace + transform + crop + acquire dependency
    RT->>RT: import as SkImage and sample into App Window
    RT->>SF: host BLAST buffer transaction: BufferTX - host layer
    SF->>SF: 更新 FrontEnd 状态 / latch 宿主 layer
    SF->>HWC: 提交宿主 layer、buffer fence 与属性

    alt presentOrValidate 返回 PresentSucceeded
        SF->>HWC: presentOrValidateDisplay
        HWC-->>SF: present executed, fences saved
    else 普通 validate 或 presentOrValidate 返回 Validated
        HWC-->>SF: changed composition types / requests
        SF->>HWC: acceptChanges
        opt 当前结果需要 CLIENT composition
            SF->>SF: RenderEngine composes client target
            SF->>HWC: setClientTarget(output acquire fence)
        end
        SF->>HWC: presentDisplay
        HWC-->>SF: present fence fd + layer release fence fds
    end
    HWC->>DD: 提交 display frame
    DD-->>SF: present fence 后续异步 signal

    SF-->>RT: host layer release channel
    RT-->>ST: release old SurfaceTexture slot with release fence
    ST-->>P: external slot becomes reusable after dependency completes
```

图里有两个“提交完成”都不等于用户可见：外部 `queueBuffer()` 只把内容交到应用进程内的 SurfaceTexture Consumer；宿主 `queueBuffer()` 只把最终窗口内容交给 BLAST/SF。用户可见结果还取决于 acquire fence、宿主 GPU、SF/HWC 与 display present。

`PresentSucceeded` 表示合并 HAL 调用已走 present 分支并保存 fences，不能再把后面的 `presentAndGetReleaseFences()` 画成必经调用，也不能写成 panel 已扫描完成。

## 2. 类型判定：怎样证明页面使用 TextureView 路径

视频、相机或 EGL 输出不等于 TextureView。定型至少需要以下证据：

1. 外部 Producer 的目标是 `SurfaceTexture` / 由它创建的 `Surface`；
2. SurfaceTexture Consumer 位于应用 HWUI 路径，能找到 `TextureView`、`TextureLayer`、pending layer update 或 `DeferredLayerUpdater` 相关状态；
3. SurfaceFlinger layer tree 没有与这条输入流对应的独立可见 buffer layer，主体像素最终出现在宿主 App Window buffer；
4. 新外部帧通过 `onFrameAvailable → updateLayer/invalidate → 宿主 frame` 影响显示；
5. 宿主 RenderThread/GPU 对外部 buffer 进行采样，再提交宿主 BLAST buffer。

下面这些信号不能单独定型：

- `SurfaceTexture` 类名：应用也可以自己用 GLConsumer 消费，不一定交给 TextureView；
- EGL swap、MediaCodec 或 camera service：它们只证明存在 Producer；
- 只有宿主 App Window layer：普通 HWUI 页面同样只有这个主体 layer；
- 宿主 GPU 较忙：普通阴影、模糊、图片和 Compose 绘制也会增加 GPU 成本。

可靠判断要同时连接外部 queue、TextureView listener/HWUI consumer 和宿主窗口提交。

## 3. 选择原因：为什么接受一次宿主采样

TextureView 的优势是内容进入宿主 View 合成语义：

- 可以使用普通 View 的 alpha、rotation、scale、translation 与 transition；
- 可以被父 View 裁剪，并与兄弟 View 按常规绘制顺序混合；
- `setTransform(Matrix)` 可以调整内容在 TextureView bounds 内的采样变换；
- 截取宿主窗口、做统一视觉效果或复杂转场时，内容已经位于宿主栅格化结果中。

代价是多一个 Consumer 和一次宿主采样：

- 外部 buffer 先进入 SurfaceTexture 队列，宿主帧到来后才被消费；
- 高分辨率内容会增加宿主 GPU 采样与内存带宽；
- format/dataspace 需要的颜色处理、缩放、alpha 与裁剪都落入宿主 GPU 路径；
- HWC 看不到 TextureView 区域的独立 layer，无法单独为它分配 overlay；
- protected 内容通常不能由普通 HWUI 上下文读取，播放器和相机安全场景往往要求独立受保护 Surface 路径。

### 选择边界

下面的判断树用于决定内容应保留在宿主窗口中，还是改用独立 Surface 承载。

```text
内容需要普通 View 级的复杂变换或交叉混合？
├── 是：评估 TextureView，并测量宿主 GPU、延迟与内存带宽
└── 否：继续判断是否需要独立 Surface
    ├── 需要低复制/overlay/protected 路径：优先评估 SurfaceView
    └── 生产内容本来就在宿主 HWUI：保留普通 View / Compose
```

这不是固定性能排名。小尺寸、低帧率 TextureView 的额外成本可能很低；复杂多 layer 页面中的 SurfaceView 也可能因 HWC 资源不足回到 client composition。选择应基于目标分辨率、帧率、视觉效果、保护要求和设备组合能力。

## 4. 系统结构：SurfaceTexture、TextureLayer 与 App Window

### 4.1 两套 Producer/Consumer

TextureView 页面至少存在两套 buffer 周转：

```text
External Producer
  → SurfaceTexture BufferQueue
  → app-process HWUI Consumer / DeferredLayerUpdater
  → GPU texture sampling
  → App Window buffer Producer
  → host BLASTBufferQueue
  → SurfaceFlinger Consumer / HWC
```

第一套队列的 Consumer 在应用进程，第二套队列的 Consumer 面向 SurfaceFlinger 显示链。两套队列拥有各自的 slot、acquire/release fence 与背压，不能用宿主 `BufferTX` 推断外部 SurfaceTexture 队列深度。

### 4.2 Java 与 native 对象

Android 17 的主要对象关系是：

- `TextureView`：View 生命周期、listener、dirty 标记、transform、opaque 与绘制入口；
- `SurfaceTexture`：向 Producer 暴露 BufferQueue producer 端，并承载 frame-available 通知；
- `TextureLayer`：Java HWUI layer，调用 native `DeferredLayerUpdater`，通过 `HardwareRenderer.pushLayerUpdate()` 进入 RenderThread；
- `DeferredLayerUpdater`：RenderThread 侧取得最新 `AHardwareBuffer`，创建/更新 `SkImage`，保存 crop、transform、dataspace 和 HDR 信息；
- App Window `Surface` / BLAST：接收宿主 HWUI 最终 buffer，并把它提交给 SurfaceFlinger。

HWUI 内部的 `TextureLayer` 不是 SurfaceFlinger layer。两者都使用“layer”一词，但一个是应用内渲染对象，一个是系统合成对象。trace Review 必须写出对象所属进程和消费者。

### 4.3 硬件加速是前提

Android `TextureView` 类契约明确规定：只能用于硬件加速窗口；软件渲染时不绘制内容。Android 17 的 `onAttachedToWindow()` 会在未开启硬件加速时记录 warning，`draw()` 也只在 `canvas.isHardwareAccelerated()` 时创建和绘制 `TextureLayer`。

这条约束与“外部 Producer 能否继续 queue”无关。Producer 可能仍在输出，TextureView 却因为宿主不是硬件加速窗口而没有可见结果。黑屏排查应同时看窗口硬件加速、SurfaceTexture 生命周期和 Producer 状态。

### 4.4 opaque 与 transform

TextureView 默认假设内容 opaque。调用 `setOpaque(false)` 会改变 HWUI layer 的 blending 语义，可能增加混合成本；它不会自动让 Producer buffer 具有正确 alpha。

`setTransform(Matrix)` 只改变 SurfaceTexture 内容在 TextureView bounds 内的采样变换，不改变 View 的 layout bounds 与触摸命中区域。预览方向、镜像、center-crop 与触摸坐标映射需要使用同一套变换关系，否则画面和交互会错位。

## 5. 生命周期：SurfaceTexture 的可用期和所有权

`TextureView.SurfaceTextureListener` 是应用可依赖的生命周期边界：

| 回调 | 精确含义 | 应用责任 |
|---|---|---|
| `onSurfaceTextureAvailable()` | TextureView 已有可用 SurfaceTexture 和当前尺寸 | 创建 `Surface`，连接单一 Producer；保存并管理 `Surface` 的 release |
| `onSurfaceTextureSizeChanged()` | TextureView 尺寸改变，默认 buffer size 已更新 | 更新 Producer 输出尺寸、viewport 或采样变换；避免无意的大比例缩放 |
| `onSurfaceTextureUpdated()` | UI 线程的 `applyUpdate()` 已调用 `TextureLayer.updateSurfaceTexture()` | 只能当更新请求通知，不能证明 RenderThread 已 acquire、GPU 已采样或用户已看到 |
| `onSurfaceTextureDestroyed()` | TextureView 即将放弃当前 SurfaceTexture | 返回 true 由 TextureView release；返回 false 表示调用方接管，之后必须自行 release |

Android 类文档还规定同一 TextureView 同时只能有一个 Producer。Camera preview 和 `lockCanvas()` 不能并发写同一个 SurfaceTexture。

### 所有权容易出错的两个入口

1. `setSurfaceTexture(newTexture)` 会立即 release 旧 SurfaceTexture，不调用旧对象的 `onSurfaceTextureDestroyed()`；传入的新对象也不会触发 `onSurfaceTextureAvailable()`。调用前，新对象必须与所有 GL 上下文 detach。
2. `onSurfaceTextureDestroyed()` 返回 false 后，TextureView 不会 release。调用方若既不复用也不 release，会保留 BufferQueue、GraphicBuffer 和 native 资源。

下面是应用自有 Producer 的生命周期骨架。`FrameProducer` 不是 Android SDK 类型。

```kotlin
private interface FrameProducer {
    fun attach(surface: Surface, width: Int, height: Int)
    fun resize(width: Int, height: Int)
    fun detachAndWaitUntilIdle()
}

private var producerSurface: Surface? = null

textureView.surfaceTextureListener = object : TextureView.SurfaceTextureListener {
    override fun onSurfaceTextureAvailable(st: SurfaceTexture, width: Int, height: Int) {
        producerSurface = Surface(st).also { frameProducer.attach(it, width, height) }
    }

    override fun onSurfaceTextureSizeChanged(st: SurfaceTexture, width: Int, height: Int) {
        frameProducer.resize(width, height)
    }

    override fun onSurfaceTextureUpdated(st: SurfaceTexture) = Unit

    override fun onSurfaceTextureDestroyed(st: SurfaceTexture): Boolean {
        frameProducer.detachAndWaitUntilIdle()
        producerSurface?.release()
        producerSurface = null
        return true
    }
}
```

这段代码强调两个等待边界：Producer 停止触碰旧目标后，`onSurfaceTextureDestroyed()` 才返回；应用创建的 `Surface` 由应用 release。MediaCodec、Camera、EGL/Vulkan 的停止与切换 API 不同，需要按实际 Producer 实现。

### visibility 与 detach

Android 17 的 `onVisibilityChanged()` 在 TextureView 不可见时移除 `OnFrameAvailableListener`，减少无意义的宿主更新；恢复可见时重新注册 listener，并调用 `updateLayerAndInvalidate()`。View detach 时会销毁 hardware layer，并按 listener 返回值处理 SurfaceTexture。

所以，不可见期间 Producer 继续 queue 并不保证宿主消费；恢复后可能直接取队列中的最新 buffer。Tab 切换、RecyclerView 复用和前后台切换出现旧帧时，要把 listener 是否注册、Producer 是否继续、SurfaceTexture 是否被替换一起检查。

## 6. 调度与消费：onFrameAvailable 怎样触发宿主帧

### 6.1 frame-available 回调

`TextureView.getTextureLayer()` 创建或绑定 SurfaceTexture 后执行：

```text
SurfaceTexture.setOnFrameAvailableListener(mUpdateListener, mAttachInfo.mHandler)

mUpdateListener.onFrameAvailable(surfaceTexture)
  updateLayer()   // set mUpdateLayer = true
  invalidate()    // mark host View dirty
```

这份概念骨架直接对应 Android 17 `TextureView.java`。handler 决定回调进入宿主 ViewRoot 线程；回调不是 RenderThread acquire，也不是独立 VSync。

### 6.2 invalidate 的合并规则

`invalidate()` 会把 dirty region 送到 ViewRoot。若 traversal 已安排或当前正在绘制，更新可能并入已有宿主帧；没有 pending frame 时，`scheduleTraversals()` 注册 traversal VSync callback，`Choreographer` 再申请下一次 VSync。

因此，外部 `queueBuffer()` 到可见帧有三种常见时序：

- **赶上已排宿主帧的 TextureLayer acquire**：当前帧采到新 buffer；
- **回调并入当前 traversal，但到达晚于 RenderThread acquire**：本轮仍采旧 buffer，下一轮才更新；
- **宿主没有 pending frame**：回调触发新的宿主帧请求，至少还要经过一次 app frame 和窗口提交。

不能把每个 `onFrameAvailable()` 与一个独立 `vsync-app` 一一对应，也不能仅凭 Producer swap 在主线程 `doFrame` 之前就断言一定赶上当前帧。关键截止点是 RenderThread 处理该 TextureLayer pending update 的时刻。

### 6.3 UI 更新与 RenderThread acquire 分开

Android 17 的职责骨架如下；这是源码结构示意，不是可编译调用栈。

```text
UI thread
TextureView.draw(hardwareAcceleratedCanvas)
  getTextureLayer()
  applyUpdate()
    TextureLayer.prepare(width, height, opaque)
    TextureLayer.updateSurfaceTexture()
      HardwareRenderer.pushLayerUpdate(layer)
    listener.onSurfaceTextureUpdated(surfaceTexture)
  recordingCanvas.drawTextureLayer(layer)

RenderThread
DrawFrameTask::syncFrameState()
  apply pending layer updates
    DeferredLayerUpdater::apply()
      ASurfaceTexture_dequeueBuffer(...)
      discard older pending frames, keep latest
      import AHardwareBuffer and update SkImage
  CanvasContext::prepareTree()
CanvasContext::draw()
  sample TextureLayer into App Window buffer
```

`onSurfaceTextureUpdated()` 的名字很容易造成误判。它发生在 UI 线程提交 layer update 之后，早于 RenderThread 的实际 acquire；不能用它测量外部帧到显示的完成时间。

## 7. 版本演进：Android 12 到 Android 17

| 平台 | TextureView/HWUI 相关变化 | 对 trace 与 Review 的影响 |
|---|---|---|
| Android 12 / API 31 | `DeferredLayerUpdater` 已使用 `ASurfaceTexture_dequeueBuffer()`、`AHardwareBuffer`、`SkImage`，并取得 SurfaceTexture Consumer ownership | Android 12 已不能只用旧 `updateTexImage()` 调用名解释 HWUI TextureView；消费点在 RenderThread pending layer update |
| Android 13 / API 33 | `DeferredLayerUpdater` 增加 CTA-861.3 / SMPTE 2086 HDR metadata 读取，并把最大 luminance 信息交给 HWUI layer | HDR TextureView 除 dataspace 外还要看 metadata；最终 tone/color 结果仍取决于 Skia、display 与设备能力 |
| Android 14 / API 34 | 本文跟踪的 listener→TextureLayer→DeferredLayerUpdater→App Window 主拓扑延续，没有需要改画主流程的公开结构变化 | 不应把 SurfaceView 在 API 34 的 alpha/lifecycle 新规则套给 TextureView |
| Android 15 / API 35 | `TextureView` 源码加入受 `toolkitSetFrameRateReadOnly` flag 控制的 `SurfaceTexture.OnSetFrameRateListener`，把输入流 frame-rate 请求转成 View requested frame rate | 这是 frame-rate hint 桥接，不是强制切换显示刷新率；必须确认 flag、Producer 请求、窗口和系统刷新率策略 |
| Android 16 / API 36 | Android 15 的 frame-rate bridge 与既有 AHardwareBuffer/SkImage 消费路径继续存在，核心拓扑不变 | 跨版本差异优先排查设备刷新率策略、GPU backend、vendor driver 与应用版本 |
| Android 17 / API 37 | 本文当前锚点延续上述结构；`DeferredLayerUpdater` 处理 crop、transform、dataspace、HDR metadata 与每个 slot 的 SkImage 缓存 | 所有方法名按 `android-17.0.0_r1` 核查；当前存在的机制不能自动写成 Android 17 首次引入 |

### Android 12：当前消费模型已经成立

Android 12 的 `DeferredLayerUpdater::apply()` 已调用 `ASurfaceTexture_dequeueBuffer()`，取得 `AHardwareBuffer` 后创建 Skia image，并在需要时等待/生成 fence。旧文章常把 TextureView 的每帧消费写成 `SurfaceTexture.updateTexImage()`；该方法仍是公开 SurfaceTexture/GLConsumer 语义的一部分，但不是 Android 12—17 HWUI TextureView 主路径的准确源码落点。

### Android 13：HDR metadata 进入 HWUI layer

Android 13 tag 相比 Android 12 增加 HDR10 SMPTE 2086 与 CTA-861.3 metadata 的读取，计算内容最大 luminance 并更新 layer。Review HDR 视频或相机预览时，不能只看 `PixelFormat` 或“是否 TextureView”；要同时看 AHardwareBuffer format、dataspace、metadata、宿主窗口颜色策略和最终 composition。

### Android 14：拓扑稳定

Android 14 没有改变本文的两套队列关系：外部 SurfaceTexture 仍由应用 HWUI 消费，宿主 App Window 仍通过 BLAST 进入 SurfaceFlinger。版本变化若只出现在 SurfaceView API，不能迁移成 TextureView 结论。

### Android 15：frame-rate 请求向 View 体系传递

在 flag 开启时，TextureView 为 SurfaceTexture 注册 `OnSetFrameRateListener`。Producer 对 native window 的 frame-rate 请求可以更新 TextureView 的 requested frame rate 与 compatibility。系统随后如何选择 display mode，还要结合窗口、其它 layer、FrameRateOverride 与刷新率策略；这条 listener 不保证 24 fps 内容一定切到 24/48/120 Hz。

### Android 16：主线延续

Android 16 的 TextureView 继续使用相同的应用内 Consumer 和宿主再提交路径。没有结构替换时，跨版本性能变化更可能来自应用构建、Producer cadence、Skia backend、GPU driver、刷新率策略或 vendor backport。结论仍需 trace 证据。

### Android 17：当前实现

Android 17 的 `DeferredLayerUpdater` 按 slot 复用 `SkImage` 包装；buffer、dataspace 或内容变化时更新 image，处理当前 crop、window transform 与 HDR 最大 luminance。`ASurfaceTexture_dequeueBuffer()` 仍保留“丢弃除最新一帧外的 pending frame”注释。

TextureView 会优先显示最新可用内容，但“丢弃旧 pending frame”不等于端到端低延迟：Producer 迟到、listener 排队、宿主错过 acquire、宿主 GPU 过载或窗口 BLAST 背压仍会增加延迟。

### 固定版本来源

- [Android 12 `DeferredLayerUpdater.cpp`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-12.0.0_r1/libs/hwui/DeferredLayerUpdater.cpp)：确认 AHardwareBuffer/SkImage 消费基线；
- [Android 13 `DeferredLayerUpdater.cpp`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-13.0.0_r1/libs/hwui/DeferredLayerUpdater.cpp)：确认 HDR metadata 处理；
- [Android 14 `TextureView.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-14.0.0_r1/core/java/android/view/TextureView.java)：确认 listener、生命周期和宿主更新拓扑；
- [Android 15 `TextureView.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-15.0.0_r1/core/java/android/view/TextureView.java)：确认 gated frame-rate listener；
- [Android 16 `DeferredLayerUpdater.cpp`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-16.0.0_r1/libs/hwui/DeferredLayerUpdater.cpp)：确认主消费路径延续；
- [Android 17 `TextureView.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/core/java/android/view/TextureView.java) 与 [`DeferredLayerUpdater.cpp`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/libs/hwui/DeferredLayerUpdater.cpp)：确认本文当前实现。

## 8. 同步与成本：两套队列、三类 fence、一次宿主 GPU 采样

### 8.1 外部 acquire fence

Producer 随 buffer 提交完成 fence。HWUI Consumer 在安全读取前必须遵守依赖；来源可能是 GPU、codec、camera、blitter 或其它硬件。等待可能体现在 CPU `sync_wait`、RenderThread fence wait、GPU-side wait 或 driver queue，不能只用一条 RenderThread slice 判断来源。

### 8.2 SurfaceTexture release fence

HWUI 不再使用旧输入 buffer 后，将 release fence 与 slot 归还 SurfaceTexture BufferQueue。Producer 后续 `dequeueBuffer()`、EGL swap 或 codec/camera output 可能因没有可复用 slot 而等待。

外部队列背压的证据是目标 SurfaceTexture 队列状态、Producer dequeue、对应 release fence 和消费 cadence；宿主 App Window 的 `BufferTX` 不足以说明这条队列堵塞。

### 8.3 宿主窗口 acquire/release fence

宿主 GPU 将 TextureView 与其它 View 画入 App Window buffer，并向宿主 BLAST 提交完成 fence。SurfaceFlinger/HWC 使用窗口 buffer 前遵守这条 acquire dependency；HWC 完成读取后返回宿主 release fence。

同一帧可能先在外部 acquire fence 上等待，又在宿主 GPU 执行和宿主窗口 release channel 上受限。把所有 fence 都写成“GPU fence”会丢失队列所有权。

### 8.4 present fence

present fence 是 display present 的时间反馈，不属于某个 TextureView 输入 slot。它的 signal 是 Android 显示栈边界，不等于面板光学响应或用户视觉感知。

### 8.5 宿主 GPU 采样成本

外部 buffer 通常通过 AHardwareBuffer import 形成 GPU 可采样 image，避免 CPU 把整帧像素再复制一遍。但“零 CPU 像素拷贝”不等于零成本，仍可能包含：

- 外部 image import、缓存/所有权与 fence 处理；
- 缩放和过滤；
- format/dataspace 对应的颜色转换；
- alpha、blend、clip、rotation 和 transform；
- 高分辨率输入带来的采样带宽；
- 宿主 App Window 的完整 GPU render pass 与最终 buffer 写入。

不能固定写成“每帧上传 YUV 纹理”。实际 buffer 可能以 external format、multi-planar image 或 driver 支持形式被采样；是否发生 YUV→RGB、在何处发生以及代价多少，取决于 format、dataspace、Skia backend 和 driver。

### 8.6 HWC 只看最终宿主 layer

TextureView 内容已进入 App Window buffer，HWC 无法把其中一个矩形区域重新拆成独立 video overlay。宿主 layer 本身仍可能走 DEVICE，也可能与其它 layer 一起进入 CLIENT；这不等于 TextureView 获得独立 overlay。

protected buffer 通常要求端到端硬件保护路径。普通 HWUI TextureView Consumer 需要读取并采样输入，不适合承载无法被非保护上下文读取的 DRM buffer。实际播放器常拒绝选择 TextureView、输出黑屏或改用 secure SurfaceView；最终行为由 DRM、codec、gralloc 和设备能力决定。

## 9. 源码入口：Android 17 应该跟读哪里

### Platform：`android-17.0.0_r1`

| 核查点 | 一手来源 | 用来确认什么 |
|---|---|---|
| TextureView 契约与实现 | [AOSP `TextureView.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/core/java/android/view/TextureView.java)、[SDK reference](https://developer.android.com/reference/android/view/TextureView) | 硬件加速、listener、所有权、draw/applyUpdate、frame available、visibility |
| SurfaceTexture 公共语义 | [AOSP `SurfaceTexture.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/graphics/java/android/graphics/SurfaceTexture.java)、[SDK reference](https://developer.android.com/reference/android/graphics/SurfaceTexture) | Producer/Consumer、frame callback、公开 `updateTexImage()` 与 release 语义 |
| Java HWUI layer | [AOSP `TextureLayer.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/graphics/java/android/graphics/TextureLayer.java) | native updater、`pushLayerUpdate()`、paint/transform/SurfaceTexture 绑定 |
| RenderThread Consumer | [AOSP `DeferredLayerUpdater.cpp`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/libs/hwui/DeferredLayerUpdater.cpp) | dequeue latest AHardwareBuffer、fence callback、SkImage、crop/transform/dataspace/HDR |
| 宿主 HWUI frame | [AOSP `DrawFrameTask.cpp`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/libs/hwui/renderthread/DrawFrameTask.cpp)、[`CanvasContext.cpp`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/libs/hwui/renderthread/CanvasContext.cpp) | pending layer update、prepareTree、draw 与 App Window swap |
| 宿主调度 | [AOSP `ViewRootImpl.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/core/java/android/view/ViewRootImpl.java)、[`Choreographer.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/core/java/android/view/Choreographer.java) | invalidate、traversal 去重、VSync 请求与五类 callback |
| 外部 BufferQueue | [AOSP `BufferQueueProducer.cpp`](https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-17.0.0_r1/libs/gui/BufferQueueProducer.cpp)、[`BufferQueueConsumer.cpp`](https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-17.0.0_r1/libs/gui/BufferQueueConsumer.cpp) | slot、dequeue/queue/acquire/release 与 backpressure |
| 宿主 BLAST/SF/HWC | [AOSP `BLASTBufferQueue.cpp`](https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-17.0.0_r1/libs/gui/BLASTBufferQueue.cpp)、[SurfaceFlinger FrontEnd](https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-17.0.0_r1/services/surfaceflinger/FrontEnd/)、[`HWComposer.cpp`](https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-17.0.0_r1/services/surfaceflinger/DisplayHardware/HWComposer.cpp) | 宿主 buffer transaction、snapshot/latch、validate/present 与 fences |
| 宿主帧时间线 | [Perfetto FrameTimeline](https://perfetto.dev/docs/data-sources/frametimeline) | 宿主 SurfaceFrame、DisplayFrame、expected/actual、token 与 jank 字段 |

旧版或应用自管 GLConsumer 场景可参考 [AOSP `GLConsumer.cpp`](https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-17.0.0_r1/libs/gui/GLConsumer.cpp)。它解释 `updateTexImage()`、external texture 与 acquire/release 语义，但不能替代 Android 17 HWUI `DeferredLayerUpdater` 的实际调用名。

### Kernel：`android17-6.18-2026-06_r6`

- [`drivers/dma-buf/sync_file.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/drivers/dma-buf/sync_file.c)：fence 作为 fd 的用户空间接口；
- [`drivers/dma-buf/dma-fence.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/drivers/dma-buf/dma-fence.c)：signal、callback、wait 的同步原语。

这些文件不能说明某台设备的 GPU/codec/camera fence 为什么迟到。具体创建者仍需结合驱动、vendor service 与硬件轨迹。

## 10. Perfetto 证据链：按两次生产复原一帧

### 10.1 建立对象表

采集后先记录：

| 对象 | 身份字段 | 主要时间点 |
|---|---|---|
| 外部 Producer | 进程/线程、目标 Surface/BufferQueue、buffer frame | dequeue、开始/结束填充、queue、completion fence |
| SurfaceTexture 队列 | producer/consumer、slot、queued/acquired | frame available、acquire latest、release old slot |
| TextureView / TextureLayer | ViewRoot、handler、layer updater | listener、invalidate、applyUpdate、pending layer update |
| 宿主 App Window | layer name/id、BLAST queue | doFrame、DrawFrame、host queue、BufferTX、latch |
| DisplayFrame | display token、composition、present | validate、client target、present/release fence |

SurfaceFlinger layer tree 通常只有宿主 App Window 可见 layer，不能用它直接找 SurfaceTexture 输入 slot。第一套队列要从应用/Producer trace、BufferQueue 名、SurfaceTexture 回调或业务 instrumentation 回溯。

### 10.2 对齐外部 Producer

先回答：

- Producer 在哪个进程/线程生成该 frame；
- `dequeueBuffer()` 是否因 slot/release fence 等待；
- 填充完成 fence 由 GPU、codec、camera 还是其它硬件产生；
- `queueBuffer()` 与目标显示 timestamp 是否合理；
- frame-available callback 何时进入宿主 handler。

MediaCodec 和 Camera 的工作可能跨应用、系统服务、provider/HAL 与 vendor 组件，不能固定写成某个单一进程。沿目标 BufferQueue 与 fence 找责任对象比按线程名猜测可靠。

### 10.3 对齐宿主消费截止点

把这些时间放到同一轴上：

1. 外部 `queueBuffer()`；
2. `onFrameAvailable()`；
3. `invalidate()` / `scheduleTraversals()`；
4. 宿主 `Choreographer#doFrame()`；
5. UI `TextureView#draw/applyUpdate`；
6. RenderThread `syncFrameState` / pending layer apply；
7. `ASurfaceTexture_dequeueBuffer()` 对应的最新 frame；
8. 宿主 GPU draw 与 host `queueBuffer()`。

如果 callback 早到但 acquire 仍取到旧 frame，检查 pending update 是否进入该 RenderThread frame、目标 buffer acquire fence 是否可用以及 trace 对象是否配错。如果 callback 到得晚于 layer apply，等待下一宿主帧是符合实现的结果。

### 10.4 分开两套背压

| 等待位置 | 所属队列 | 常见上游 |
|---|---|---|
| 外部 Producer `dequeueBuffer` / swap | SurfaceTexture 队列 | HWUI 消费慢、旧 slot release fence 未完成、Producer 过快 |
| RenderThread acquire/fence wait | SurfaceTexture 队列 | 外部 buffer 尚未完成、driver import/ownership 等待 |
| 宿主 RenderThread `dequeueBuffer` | App Window BLAST 队列 | SF/HWC 尚未释放 host buffer、buffer stuffing、display backpressure |
| SF/HWC 等宿主 acquire fence | App Window BLAST 队列 | 宿主 GPU 未完成 TextureView+UI 绘制 |

同一帧可同时命中两套背压。报告中要写目标队列和 layer 名，不能只写“卡在 dequeueBuffer”。

### 10.5 FrameTimeline 的用法

FrameTimeline 主要覆盖宿主 App Window 和 SurfaceFlinger display frame。它能回答宿主帧是否按 expected timeline 完成、是否 late present、是否发生 buffer stuffing；它通常不能直接给出外部 SurfaceTexture 输入 frame 的完整 expected/actual slice。

用 `surface_frame_token` 对齐宿主 App Window，用 `display_frame_token` 对齐最终显示；外部 frame 通过 BufferQueue frame number、timestamp、callback 和 fence 另行关联。宿主 FrameTimeline late 可能来自宿主 UI，也可能是外部 acquire 或采样成本，不能只凭 `jank_type` 归因。

### 10.6 HWC 与 present

确认宿主 layer 是 DEVICE 还是 CLIENT，并检查其它系统 layer、client target 和 display mode。TextureView 内容没有独立 composition type；若工具显示宿主 layer DEVICE，只说明整块已渲染窗口由 HWC 作为一个 layer 处理，不说明视频区域直接 overlay。

present fence 只收束 Android 显示栈。需要证明相机 preview 到光学显示、触摸到光子或 panel scanout，还要额外的 sensor/display/光学测量证据。

### 10.7 可复用排查顺序

1. 证明目标是 TextureView，而非 SurfaceView 或应用自管 SurfaceTexture；
2. 找到外部 Producer 与第一套 BufferQueue；
3. 对齐 queue→frame available→invalidate；
4. 找到 UI applyUpdate 与 RenderThread acquire；
5. 检查外部 acquire/release fence 与 slot；
6. 检查宿主 GPU 采样和 host queue；
7. 对齐宿主 `BufferTX - <layerName>`、latch、composition 与 present；
8. 用目标显示帧验证用户看到的是新输入还是复用内容。

## 11. 类型边界与故障模式

### 11.1 TextureView 与 SurfaceView

| 维度 | TextureView | SurfaceView |
|---|---|---|
| 外部 stream Consumer | 应用 HWUI / DeferredLayerUpdater | SurfaceFlinger 可见的独立 BLAST layer 路径 |
| 最终可见 layer | 主体像素进入宿主 App Window | 主体保持独立 buffer layer |
| View 变换 | 可按普通 View 语义采样、混合、裁剪 | 依赖 SurfaceControl 几何、composition order 与 hole-punch |
| HWC | 无法单独评估 TextureView 区域 | 可对独立 layer 评估 DEVICE/CLIENT |
| protected content | 普通 HWUI 采样通常不适用 | 可建立 secure/protected 独立路径 |
| 队列 | 外部队列 + 宿主窗口队列 | SurfaceView 内容队列 + 宿主窗口队列，两者在 SF 组合 |

SurfaceView 不等于必定更快，TextureView 也不等于必定多一整帧。差异是结构：TextureView 必须经过宿主 acquire/采样/再提交；是否跨过额外 VSync 取决于时序和负载。

### 11.2 TextureView 与普通 HWUI

普通 ImageView/Compose 图片的资源准备可能也有异步解码和 GPU upload，但它们不一定存在持续的外部 SurfaceTexture Producer。TextureView 定型需要找到第一套 BufferQueue 和 frame-available 回流。

### 11.3 TextureView 与 WebView/Flutter

WebView、Flutter 或其它引擎可能选择 TextureView 作为某个宿主/PlatformView 输出，也可能使用 SurfaceView、普通 App Window、SurfaceControl 嵌入或其它组合。框架名不能替代 layer/BufferQueue 拓扑。先确认最终承载方式，再进入引擎线程分析。

### 11.4 故障模式

| 现象 | 首要检查 | 不应直接下的结论 |
|---|---|---|
| Producer 已 queue，画面仍旧 | callback、宿主 frame、RT acquire、取得的 frame number | Producer queue 等于用户可见 |
| 宿主 `DrawFrame` 变长 | 外部 fence wait、image import、采样/缩放、其它 View/GPU 工作 | TextureView shader 一定慢 |
| Producer swap/dequeue 变长 | SurfaceTexture slot 与 release fence、HWUI 消费 cadence | Producer CPU 计算慢 |
| 宿主 FrameTimeline late | 外部到达、RT acquire、宿主 UI/GPU、host BLAST、SF/HWC | 一定是 main thread |
| 预览跳帧但延迟较低 | `ASurfaceTexture_dequeueBuffer()` 是否丢弃旧 pending frame、Producer cadence | BufferQueue 数据损坏 |
| TextureView 黑屏 | 硬件加速、SurfaceTexture 生命周期、Producer connect、protected 属性 | SF 没有独立 TextureView layer 是 bug |
| 前后台恢复后卡旧帧 | visibility listener、SurfaceTexture 是否替换、Producer 是否重连 | Activity resumed 就应立即有新帧 |
| 视频功耗高于 SurfaceView | 宿主 GPU 采样、分辨率/缩放、HWC 无独立 overlay、刷新率 | 所有设备上 TextureView 都固定更耗电 |
| HDR 颜色/亮度异常 | format、dataspace、HDR metadata、宿主 window 与 display policy | 只看 API 版本或只看 metadata |
| 触摸与预览坐标错位 | View layout matrix、TextureView transform、Producer crop/rotation | Camera HAL 坐标一定错误 |

### Review 清单

1. TextureView 是否运行在硬件加速窗口？
2. 谁创建 SurfaceTexture，谁创建和 release `Surface`？
3. `onSurfaceTextureDestroyed()` 返回值与资源所有权是否一致？
4. 同一时刻是否只有一个 Producer？
5. Producer buffer 尺寸、format、dataspace 与 View bounds 是否匹配？
6. `onFrameAvailable()` 投递到哪个 looper，是否被主线程工作延迟？
7. 外部 frame 是否赶上目标 RenderThread layer apply？
8. 三类 fence 分别属于外部输入、宿主窗口还是 display present？
9. HWC 看到的是哪个宿主 layer，是否有人误称为 TextureView overlay？
10. Android/Jetpack/vendor 版本是否固定，版本变化是否有对应源码或 trace 证据？

## 总结

TextureView 把外部 buffer stream 交给应用内 HWUI Consumer。`onFrameAvailable()` 只触发 `updateLayer()` 与宿主 `invalidate()`；UI `applyUpdate()` 只记录 TextureLayer 更新；RenderThread 才在 `DeferredLayerUpdater::apply()` 里取得最新 `AHardwareBuffer`，将它作为 `SkImage` 采样进 App Window。SurfaceFlinger 最终只接收宿主窗口 buffer。

排查时必须保留两套 BufferQueue 和三类同步：外部 SurfaceTexture acquire/release、宿主窗口 acquire/release、display present。外部 queue 按时不代表宿主已经采样，宿主 FrameTimeline late 也不自动证明问题来自主线程。

版本上，Android 12 已是 AHardwareBuffer/SkImage 消费基线，Android 13 加入 HDR metadata，Android 15 增加受 flag 控制的 frame-rate 请求桥接，Android 16 延续该主线，Android 17 是本文当前实现。所有“从某版本开始”的结论都应由对应 tag 或公开 API 文档支持。

GENERATED FILE - DO NOT EDIT.
Source: docs/rendering_pipelines/S05_mixed_rendering_type.md
Source SHA-256: 0df7e009bcbd198f98837a68719d5fa39a04b17fb1b7ef752b700112ae5cdfd2

# Android Perfetto 系列 - App 出图类型 - 混合出图类型

混合出图页面同时使用两种以上的内容生产与显示方式。宿主 HWUI、`TextureView` 输入流、`SurfaceView`、嵌入式 `SurfaceControlViewHost`、视频或相机 Producer 可能出现在同一屏，任意两路都能采用不同帧率、队列和同步规则。

Perfetto 分析的难点不在“layer 数量多”，而在每个可见对象由谁生产、在哪里被消费、几何由谁控制、当前 display frame 使用了哪一块 buffer。本文给出一套按对象建表、再按显示周期复原画面的办法。

<!--more-->

## 阅读导航

### 本文目录

- 阅读说明
- 1. 一帧完整流程：多路内容怎样形成一个 DisplayFrame
- 2. 类型判定：哪些页面属于混合出图
- 3. 三种拓扑：宿主回流、独立 layer 与两者并存
- 4. 对象清单：Producer、Consumer、几何和帧节奏
- 5. 生命周期与模式切换：黑屏和旧帧的第一检查点
- 6. 同步规则：原子 Transaction、SurfaceSyncGroup 与 fence
- 7. SurfaceFlinger：多路状态怎样进入本轮合成
- 8. HWC：整屏 layer 集合怎样改变合成成本
- 9. 版本演进：Android 12 到 Android 17
- 10. 源码入口：Android 17 应该跟读哪里
- 11. Perfetto 证据链：按对象复原一次混合显示
- 12. 类型边界与故障模式
- 总结

### 系列文章目录

1. [Android Perfetto 系列 - App 出图类型 - 总览与识别方法](S01_rendering_types_overview.md)
2. [Android Perfetto 系列 - App 出图类型 - AOSP 标准类型](S02_aosp_standard_type.md)
3. [Android Perfetto 系列 - App 出图类型 - SurfaceView 类型](S03_surfaceview_type.md)
4. [Android Perfetto 系列 - App 出图类型 - TextureView 类型](S04_textureview_type.md)
5. [Android Perfetto 系列 - App 出图类型 - 混合出图类型](S05_mixed_rendering_type.md)
6. [Android Perfetto 系列 - App 出图类型 - 多窗口类型](S06_multi_window_type.md)
7. [Android Perfetto 系列 - App 出图类型 - Software / 离屏类型](S07_software_offscreen_type.md)
8. [Android Perfetto 系列 - App 出图类型 - Native Graphics 类型](S08_native_graphics_type.md)
9. [Android Perfetto 系列 - App 出图类型 - WebView 类型](S09_webview_type.md)
10. [Android Perfetto 系列 - App 出图类型 - Flutter 类型](S10_flutter_type.md)
11. [Android Perfetto 系列 - App 出图类型 - Camera 类型](S11_camera_type.md)
12. [Android Perfetto 系列 - App 出图类型 - Video Overlay / HWC 类型](S12_video_overlay_hwc_type.md)
13. [Android Perfetto 系列 - App 出图类型 - Game 类型](S13_game_type.md)
14. [Android Perfetto 系列 - App 出图类型 - React Native 类型](S14_react_native_type.md)

## 阅读说明

平台源码固定到 Android 17 / API 37 的 `android-17.0.0_r1`，kernel 源码固定到 `android17-6.18-2026-06_r6`。View/HWUI、`SurfaceView`、`TextureView`、BLAST、SurfaceFlinger FrontEnd、CompositionEngine 和 HWC 的名称按平台 tag 核查；sync file 与 dma-fence 按指定 kernel tag 核查。

Camera、codec、Web/地图引擎、Flutter、游戏和厂商 Composer 可能改变 Producer 进程、buffer format 与 layer 拓扑。AOSP 只能证明公共接口和系统合成行为。目标应用采用哪种承载模式，必须从当前 layer tree、BufferQueue、应用配置和 trace 得出。

“混合出图”是本文的分析分类，不是 Android framework 中的类或窗口类型。页面只要存在两条以上可区分的内容生产路径，并且它们共同影响同一个最终画面，就需要使用本文的方法；SurfaceFlinger 是否看到多个独立 layer，要继续按拓扑分类。

## 1. 一帧完整流程：多路内容怎样形成一个 DisplayFrame

以“宿主控制层 + TextureView 地图 + SurfaceView 视频”为例，一次显示更新包含下面这些工作：

1. 宿主窗口因输入、动画、布局或重绘请求安排下一帧。`Choreographer` 在没有 pending frame 时请求新的 `vsync-app`，主线程随后处理 Input、Animation、Insets、Traversal 和 Commit。
2. 地图 Producer 把 buffer 提交给 `TextureView` 的 `SurfaceTexture`。`onFrameAvailable()` 在宿主 ViewRoot 线程调用 `updateLayer()` 与 `invalidate()`，该请求可能并入已经安排的宿主帧。
3. 宿主 `TextureView.draw()` 记录 `TextureLayer` 更新；RenderThread 在 `DeferredLayerUpdater::apply()` 中取得最新地图 buffer，将它采样进宿主 App Window。
4. 宿主 RenderThread 同时绘制按钮、遮罩和其它 View，再通过宿主 BLAST 提交 App Window buffer。TextureView 地图此时已经包含在宿主 buffer 中。
5. 视频 Producer 按解码节奏向 SurfaceView 的独立 Surface 提交 buffer。SurfaceView BLAST child 保留独立 buffer layer，不经过宿主 GPU 采样。
6. SurfaceView 的位置、crop、visibility 与相对 Z-order 由 `SurfaceControl.Transaction` 管理。默认 Z-below 场景还依赖宿主窗口中的 hole-punch。
7. SurfaceFlinger 接收宿主窗口与视频 child 的 transaction。宿主 buffer 携带当前宿主 UI 和本轮采到的地图内容；视频 child 携带它自己的 buffer、dataspace 与 acquire fence。
8. FrontEnd 更新 `RequestedLayerState` 和 `LayerSnapshot`。每个 buffer layer 分别判断 transaction readiness、buffer readiness 与 fence 条件；未更新的 layer 可以继续使用上次内容。
9. 如果业务要求多个 SurfaceControl 状态原子生效，它们应放进同一 Transaction。需要等待多个受控 Surface 产出后一起应用时，可使用 `SurfaceSyncGroup`；没有加入同步组的独立 Producer 不会被自动纳入。
10. CompositionEngine 生成本次 display 的可见 layer 集合，HWC 返回 DEVICE/CLIENT changes 与 display requests。任何 CLIENT layer 都会进入 RenderEngine client target。
11. 允许 skip validate 时，`presentOrValidateDisplay()` 可能直接返回 `PresentSucceeded`；此时 present 已执行并保存 fences。其它分支在接受 changes、设置 client target 后调用 `presentAndGetReleaseFences()`。
12. 本次 display 得到一份 present fence 和多份 per-layer release fence。present fence 描述 display present 边界；release fence 分别回到宿主与独立 Producer，控制旧 buffer 复用。

### 总体拓扑

这张图用于确认每条内容在哪里进入最终画面。拿 trace 对照时，重点找三个中转点：SurfaceTexture Consumer、宿主 BLAST、独立 Surface BLAST。

```mermaid
flowchart TD
    HostUI["Host View / Compose 状态"] --> HostRT["Host RenderThread / HWUI"]

    TextureProducer["Texture Producer<br/>map / camera / video"] --> ST["SurfaceTexture BufferQueue"]
    ST --> TextureConsumer["DeferredLayerUpdater<br/>app-process Consumer"]
    TextureConsumer --> HostRT

    HostRT --> HostBLAST["Host App Window BLAST"]
    HostBLAST --> HostLayer["Host buffer layer in SurfaceFlinger"]

    IndependentProducer["Independent Producer<br/>video / camera / embedded UI"] --> IndependentBLAST["Independent Surface / BLAST"]
    IndependentBLAST --> IndependentLayer["Independent buffer layer in SurfaceFlinger"]

    HostLayer --> FrontEnd["SurfaceFlinger FrontEnd<br/>RequestedLayerState / LayerSnapshot"]
    IndependentLayer --> FrontEnd
    FrontEnd --> CE["CompositionEngine<br/>per-display visible layer set"]
    CE --> HWC["HWComposer / Composer HAL<br/>validate or presentOrValidate"]
    HWC -. CLIENT layers .-> Client["RenderEngine client target<br/>only for CLIENT layers"]
    Client --> HWC
    HWC --> Driver["Display driver<br/>scan-out scheduling"]
    Driver --> Present["Display present feedback<br/>present + release fences"]
```

Texture 输入流在宿主 RenderThread 中结束第一套 BufferQueue 周转，随后变成宿主窗口像素。独立 Surface 保持单独的 SF buffer layer。混合页可能只有前一种，也可能同时存在两种。

### 多 layer 显示周期

下面的时序图只画 SurfaceFlinger 可见的宿主 layer 和两个独立 layer。每条 Producer 有自己的提交与 release channel。

```mermaid
sequenceDiagram
    participant Host as "Host App Window"
    participant A as "Independent layer A"
    participant B as "Independent layer B"
    participant SF as "SF FrontEnd / CompositionEngine"
    participant HWC as "HWComposer / Composer HAL"
    participant DD as "Display driver"

    Host->>SF: host buffer transaction + acquire fence
    A->>SF: buffer transaction A + acquire fence A
    B->>SF: 状态更新或 buffer transaction B

    SF->>SF: apply transactions and update snapshots
    SF->>SF: evaluate readiness per buffer layer
    SF->>SF: reuse previous content where no new buffer is selected
    SF->>HWC: submit visible layer set and request strategy

    alt presentOrValidate returns PresentSucceeded
        HWC-->>SF: present executed, fences saved
    else validate path or Validated result
        HWC-->>SF: composition changes / display requests
        SF->>HWC: acceptChanges
        opt any CLIENT layer
            SF->>SF: RenderEngine creates client target
            SF->>HWC: setClientTarget(output acquire fence)
        end
        SF->>HWC: presentDisplay
        HWC-->>SF: present fence + per-layer release fences
    end
    HWC->>DD: 提交 display frame
    DD-->>SF: present fence 后续异步 signal

    SF-->>Host: host release fence
    SF-->>A: release fence A
    SF-->>B: release fence B when applicable
```

一个 display frame 可以组合“新宿主 + 旧视频”或“旧宿主 + 新视频”。这种组合在系统层面可能合法，业务层面却可能出现遮罩、字幕、位置或内容时刻不一致。分析目标是找出哪一组状态进入了目标 present。

## 2. 类型判定：哪些页面属于混合出图

页面需要满足两个条件：

- 存在两条以上能区分 Producer 或 Consumer 的内容路径；
- 这些路径共同影响同一屏的最终可见结果。

### 常见组合

| 页面组合 | SurfaceFlinger 侧形态 | 分析入口 |
|---|---|---|
| 普通 View + TextureView | 通常只有宿主 App Window 主体 layer | 外部 queue、SurfaceTexture acquire、宿主 GPU 与 host BLAST |
| 普通 View + SurfaceView | 宿主 layer + SurfaceView container/BLAST child | 宿主帧、SurfaceView buffer、几何/hole-punch、per-layer latch |
| TextureView + SurfaceView | Texture 内容进入宿主，另有独立 SurfaceView layer | 两套输入队列、宿主采样、独立 layer、HWC |
| 多个 SurfaceView / SurfaceControl | 宿主 + 多个独立 layer | layer parent/Z-order、每路 BufferTX、同步组与 composition type |
| SurfaceControlViewHost 嵌入 | 宿主层级中存在跨进程 child hierarchy | SurfacePackage、AttachedSurfaceControl、sync group、输入与可见性 |
| WebView / Flutter / 游戏 + 原生 Surface | 取决于引擎选择的承载模式 | 先确认实际 layer/BufferQueue 拓扑，再加入引擎线程 |

只看到多个线程、多个 `queueBuffer()` 或多个 SF layer 还不够。SystemUI、壁纸、输入法和导航栏本来就会参与同一 display；本文分类关注目标页面内部由应用或嵌入内容引入的多路生产关系。

## 3. 三种拓扑：宿主回流、独立 layer 与两者并存

### 3.1 宿主回流型

外部 Producer 把 buffer 交给 `SurfaceTexture`，应用内 HWUI Consumer 取得最新内容，再画进宿主窗口。SurfaceFlinger 不会得到与该输入流一一对应的独立可见 layer。

这类页面的不同步通常发生在外部 queue 与宿主 acquire 之间：新 buffer 已到 SurfaceTexture，宿主却错过本轮 `DeferredLayerUpdater::apply()`；或者宿主取得新 buffer 后，GPU 采样和 host BLAST 提交超时。

### 3.2 独立 layer 型

`SurfaceView`、应用自管 `SurfaceControl` 或嵌入式 Surface hierarchy 以独立 layer 进入 SurfaceFlinger。宿主和独立内容各自提交，SurfaceFlinger/HWC 决定本次 display 使用哪些 buffer 和状态。

这类页面需要同时观察 buffer layer 与它的管理层。以 Android 17 SurfaceView 为例，container 承载几何，BLAST child 承载内容 buffer，背景 color layer 按条件显隐。只观察 container 的 position transaction，无法证明视频 buffer 已更新。

### 3.3 组合型

页面既有 Texture 回流，也有独立 layer。宿主 buffer 本身已经是多路输入的结果，SurfaceFlinger 又把它与独立内容组合。此时至少有三次截止：

1. 外部 Texture buffer 是否赶上宿主 RenderThread acquire；
2. 宿主 App Window 是否赶上目标 SF display frame；
3. 独立 layer 的新 buffer 与几何是否同时进入该 display frame。

报告若只写“宿主 late”或“视频 late”，信息不足。需要写清目标 present 使用的宿主 buffer、宿主内部采到的 Texture frame、独立 layer buffer 和几何状态。

## 4. 对象清单：Producer、Consumer、几何和帧节奏

混合页面开始分析前，给每个对象填一行：

| 字段 | 要记录的内容 | 证据来源 |
|---|---|---|
| 内容对象 | 视频、预览、地图、控制层、嵌入式 UI | 页面结构、layer name、业务配置 |
| Producer | 应用线程、codec、camera provider/HAL、引擎或远端进程 | BufferQueue connect、queue 调用、进程/线程轨迹 |
| Consumer | HWUI SurfaceTexture Consumer、BLAST/SF、ImageReader 或其它模块 | layer tree、BufferQueue 名、源码路径 |
| 最终 SF layer | 宿主 App Window、独立 BLAST child、color/effect layer | SurfaceFlinger layer trace/dump |
| 几何所有者 | ViewRoot、SurfaceView container、应用 Transaction、远端 host | transaction、parent、crop、matrix、relative-Z |
| 帧节奏 | `vsync-app`、视频 timestamp、sensor cadence、引擎 VSync | Choreographer、Producer timestamp、业务 trace |
| acquire/release | fence 所属 buffer 和队列 | fence fd、sync wait、release callback、driver trace |
| 同步约束 | 同一 Transaction、SurfaceSyncGroup、frame number、desired present | API 调用、transaction id、sync trace |

表格填不完整时，不适合开始归因。比如“Camera 预览卡”缺少承载对象，就无法判断 Consumer 在 HWUI、SurfaceFlinger 还是 ImageReader。

### Producer 进程不能靠固定名单判断

MediaCodec、Codec2 与 Camera 流水线可能跨应用进程、系统服务、provider/HAL 和 vendor 进程。游戏、地图和浏览器也可能把工作拆到多个线程或进程。可靠做法是从目标 BufferQueue 的 producer connection、queue 调用和完成 fence 回溯，进程名只用于缩小范围。

## 5. 生命周期与模式切换：黑屏和旧帧的第一检查点

混合页的 layer 拓扑会在运行中变化。播放器从 TextureView 切到 SurfaceView、Camera preview 重建 output、WebView 进入全屏视频、嵌入式 hierarchy reparent，都会让原有 trace 对象失效。

| 对象 | 有效期信号 | 常见失败 |
|---|---|---|
| SurfaceView | `surfaceCreated/Changed/Destroyed`、API 34 lifecycle 策略 | Producer 继续写旧 Surface、首 buffer 晚、container 已显示但 BLAST child 无内容 |
| TextureView | `onSurfaceTextureAvailable/Destroyed`、visibility listener、`setSurfaceTexture()` 所有权 | listener 被移除、旧对象泄漏、Producer 已换目标但分析仍跟旧队列 |
| SurfaceControlViewHost | SurfacePackage attach/clear/reparent、远端 binder 生命周期 | child hierarchy 已断开、同步组等待的对象退出 |
| Media/Camera output | session/output configuration、codec surface switch、secure 属性 | 切换期间无 buffer、旧 buffer 被保留、保护能力不匹配 |
| App Window | attach/detach、relayout、window surface replacement | 宿主 layer id、BLAST queue 和 FrameTimeline token 改变 |

检查黑屏时，按“对象是否存在 → Producer 是否连接 → 首 buffer 是否提交 → acquire fence 是否完成 → layer 是否可见 → HWC 是否接受”逐项确认。只看到 View 已 attach 或 `surfaceCreated()` 已回调，不能证明已有可显示 buffer。

### 拓扑切换要重新建表

模式切换前后的同名 layer 可能拥有不同 layer id、BufferQueue、Producer 和安全属性。Perfetto 时间范围跨越切换点时，应拆成两段分析；不要把旧队列的 release fence 与新 layer 的 `BufferTX` 配对。

## 6. 同步规则：原子 Transaction、SurfaceSyncGroup 与 fence

### 6.1 同一 Transaction 解决状态原子应用

`SurfaceControl.Transaction` 可以同时更新多个 SurfaceControl，并由 `apply()` 原子提交。position、crop、alpha、layer、reparent 和通过公开 `setBuffer()` 提交的 HardwareBuffer 都可以属于同一笔 Transaction。

原子提交只覆盖已经加入该 Transaction 的状态。Camera、codec 或游戏 Producer 之后向另一个 BufferQueue 提交的“下一帧”不会自动加入。业务要同步“新几何 + 新内容”，必须掌握对应 buffer transaction，或使用能等待目标 Surface 产出的同步机制。

下面的概念模型区分 Transaction 内状态和外部 Producer。它不是可编译 Java。

```text
one SurfaceControl.Transaction
  setPosition(surfaceA)
  setCrop(surfaceA)
  setAlpha(surfaceB)
  optional setBuffer(surfaceC, hardwareBuffer, acquireFence)
  apply atomically

external Producer queueBuffer(surfaceB)
  separate BufferQueue event
  not included unless framework/application explicitly coordinates it
```

这一区别解释了一个常见现象：两个 container 的几何同帧生效，某个 child 仍沿用旧 buffer。Transaction 没有丢状态，外部 buffer 不属于那笔提交。

### 6.2 SurfaceSyncGroup 等待多个受控 Surface

API 34 的 `SurfaceSyncGroup` 用来收集多个 Surface 的同步结果，支持 `AttachedSurfaceControl`、`SurfaceControlViewHost.SurfacePackage` 和附加 Transaction，也能跨进程协调。组被 `markSyncReady()` 后，要等 child sync group 完成，系统才应用最终合并 Transaction。

`SurfaceSyncGroup` 只协调加入组的对象。一个不受控制的 MediaCodec、Camera HAL 或引擎 Producer 若没有通过目标 Surface 的同步回调进入组，系统不能替业务预测它何时生成逻辑上的下一帧。

下面是公开 API 的职责形状，不是可直接复制的业务代码；各对象的获取和线程要求已省略。

```text
SurfaceSyncGroup("mixed-frame")
  add(attachedSurfaceControl, updateRunnable)
  add(surfacePackage, updateRunnable)
  addTransaction(extraSurfaceControlTransaction)
  markSyncReady()

group completes
  after registered child surfaces provide their sync transactions
  then applies the merged transaction
```

实际使用时，`add(AttachedSurfaceControl, ...)` 必须在创建该 UI 元素的线程调用，通常是主线程；runnable 在渲染暂停后执行，用于让下一帧变化进入同步组。

### 6.3 Transaction committed 与 completed

- API 33 `addTransactionCommittedListener()`：transaction 已应用，更新已经 ready to be presented；它不等于 display 已 present。
- API 35 `addTransactionCompletedListener()`：transaction 已 presented 后回调，返回 `TransactionStats`；它仍是 Android 显示栈事件，不是 panel 光学完成测量。

两个 listener 适合定位 transaction 生命周期，不能替代 Producer buffer fence 和 display present fence。

### 6.4 desired present time 与 frame timeline

API 35 `setDesiredPresentTimeNanos()` 请求 transaction 在指定单调时钟时间或之后显示。官方契约明确规定：即使请求更早时间，所有 acquire fence signal 前也不能 present。

API 35 `setFrameTimeline(vsyncId)` 把 Choreographer FrameTimeline 的 VSync id 交给 SurfaceFlinger，使 transaction 选择相应 expected presentation time。无效或过期 id 会被忽略。这两项是调度信息，不会生成 buffer，也不会消除 fence wait。

### 6.5 acquire、release 与 present fence

| fence | 粒度 | 回答的问题 |
|---|---|---|
| acquire fence | 每块输入 buffer | Producer 何时完成写入，Consumer 何时可安全读取 |
| release fence | 每个被消费的 layer/buffer | Consumer/HWC 何时不再读取，旧 buffer 何时可复用 |
| present fence | 每个 display present | 本次 display present 工作何时到达显示栈完成边界 |

TextureView 回流还会多一套 SurfaceTexture acquire/release；宿主 App Window 另有 BLAST acquire/release。报告中每个 fence 都要标明队列、layer 和方向。

### 6.6 AutoSingleLayer 不能同步混合页面

Android 13 的 `AutoSingleLayer` 允许 SurfaceFlinger 在“本帧只有单个 layer 的简单 buffer update、没有几何变化或 sync transaction”等条件下 latch unsignaled buffer，把等待推迟到读取阶段。

官方文档明确排除跨 layer、geometry changes 和 sync transactions。混合页面正好常包含这些条件，因此 `AutoSingleLayer` 不能用来解释或修复多 Surface 一致性。它只可能作用于某次满足单 layer 条件的独立更新。

## 7. SurfaceFlinger：多路状态怎样进入本轮合成

### 7.1 Android 17 FrontEnd 对象

Android 17 收到 transaction 后，FrontEnd 将请求合入 `RequestedLayerState`，通过 `LayerLifecycleManager` 管理 layer 生命周期，再由 `LayerSnapshotBuilder` 生成当前 hierarchy、可见性、几何和效果快照。buffer layer 的 readiness/latch 还要结合 buffer transaction 与 fence。

旧资料常把流程写成 `SurfaceFlinger::commit()` 里循环调用每个 `Layer::latchBuffer()`。这种骨架无法表达 Android 17 的 FrontEnd 状态和 snapshot，也容易把 container 状态与 child buffer 混成一个对象。

下面是 Android 17 的职责示意，不是源码调用栈。

```text
SurfaceFlinger transaction processing
  collect and flush pending transactions
  update RequestedLayerState
  process layer lifecycle and hierarchy
  build/update LayerSnapshot
  evaluate buffer transaction readiness per buffer layer

Composition preparation
  choose current buffer or retained previous content per layer
  build visible layer list for each display
  将 layer 状态与 fences 交给 CompositionEngine / HWC
```

这份示意把“状态已经进入 snapshot”和“新 buffer 已被当前 display 使用”分开。判断某个对象是否更新，需要同时看状态 transaction、buffer transaction、latch/selection 与目标 present。

### 7.2 没有新 buffer 时可以保留旧内容

某个 layer 没有新 buffer，不要求整个 display 等待。只要本轮有其它状态或内容需要更新，CompositionEngine 可以继续使用该 layer 已选中的上次内容。视频低帧率、宿主高刷新率时，这种复用是正常状态。

业务看到的新旧不一致来自逻辑关联：字幕与视频、遮罩与预览、地图与标记原本应属于同一业务时刻，却由不同队列在不同 display frame 更新。系统无法从像素内容推断这种关系，需要应用明确同步或接受复用。

### 7.3 transaction readiness 不等于 fence 已消失

SurfaceFlinger 可能因为 sync group、barrier、desired present、acquire fence 或其它 transaction 条件推迟一笔更新。符合 latch-unsignaled 条件时，fence wait 可以后移；HWC 或 RenderEngine 读取 buffer 前仍要遵守依赖。

Perfetto 中看到 transaction 已提交、`BufferTX - <layerName>` 增加或状态 snapshot 已更新，都不能单独证明目标 display 已使用新 buffer。

## 8. HWC：整屏 layer 集合怎样改变合成成本

HWC 每轮评估整个可见 layer 集合。SurfaceView、视频、相机、宿主窗口、系统栏、壁纸、圆角、dim、color transform 都可能影响最终 strategy。

### 8.1 影响 DEVICE/CLIENT 的条件

- buffer format、modifier、dataspace 与 HDR metadata；
- protected/secure usage 与目标 display 的保护能力；
- source crop、destination frame、scale、rotation、alpha 和 blend；
- overlay plane、scaler、bandwidth 及厂商硬件限制；
- 同屏其它 layer 对相同资源的占用；
- display mode、color mode 与全局 color transform。

YUV、SurfaceView 或视频标签都不能保证 DEVICE composition。HWC 根据当前整屏条件返回 changes。普通 layer 不满足硬件条件时可进入 CLIENT；protected layer 必须保持受保护路径，不能交给普通非保护 RenderEngine 读取。

### 8.2 layer 增加与成本没有固定线性关系

新增独立 layer 可能让视频直接走 overlay，减少宿主 GPU 采样；也可能占满 plane，让另一个大面积 layer 回到 CLIENT。一个透明遮罩、复杂 transform 或颜色要求也可能改变整屏策略。

比较前后两帧时，应记录每个可见 layer 的 composition type、client target 面积/GPU 时长、display mode 和 layer 属性变化。只比较 layer 数或总 GPU busy，无法解释 strategy 为什么变化。

### 8.3 presentOrValidate 分支

Android 17 的 `HWComposer::getDeviceCompositionChanges()` 只在满足 skip-validate 条件时尝试 `presentOrValidateDisplay()`：

- `PresentSucceeded`：组合调用已经执行 present，present/release fences 已保存；
- `Validated`：validate 已完成，SurfaceFlinger 继续读取 composition changes/requests 并 `acceptChanges()`；
- 不允许 skip validate：调用 `validateDisplay()`，随后处理 changes。

存在 CLIENT layer 时，RenderEngine 消费各 layer 输入 fence 并生成 client target，`setClientTarget()` 携带 client target output acquire fence。尚未 present 的分支再调用 `presentAndGetReleaseFences()`。

## 9. 版本演进：Android 12 到 Android 17

| 平台 | 混合出图相关变化 | 对 Review 的影响 |
|---|---|---|
| Android 12 / API 31 | BLAST 与 FrameTimeline 构成现代窗口/Surface 基线 | 可按宿主 SurfaceFrame、SF DisplayFrame、layer/BufferTX 复原多路显示；独立 Surface 的 app timeline 覆盖仍需验证 |
| Android 13 / API 33 | HWC HAL 转向 AIDL；`AutoSingleLayer` 默认启用；公开 Transaction committed listener 与 `setBuffer()` | HWC binder/trace 入口可能变化；latch unsignaled 明确不适用跨 layer 同步；应用可直接提交 HardwareBuffer 与 fence |
| Android 14 / API 34 | `SurfaceSyncGroup`、SurfaceView lifecycle 策略与任意 alpha；Transaction extended-range brightness | 跨进程受控 Surface 可加入同步组；SurfaceView 的保留/销毁和半透明行为改变混合页边界 |
| Android 15 / API 35 | desired present time、`setFrameTimeline()`、Transaction completed listener、desired HDR headroom | 应用可提供更明确的调度和完成回调；fence 与设备能力仍决定能否按目标显示 |
| Android 16 / API 36 | SurfaceView `compositionOrder` 公开，嵌入/多 Surface 的整数相对层级更易表达 | 负值位于宿主下方，非负值位于宿主上方；相同 order 的 peer 顺序未定义 |
| Android 17 / API 37 | SurfaceView blur region 公开；本文固定到当前 FrontEnd snapshot、BLAST 与 HWC 流程 | blur、crop、transform 与位置要一起检查；当前代码存在不等于 Android 17 首次引入 |

### Android 12：现代基线

Android 12 已经使用 BLAST 组织 App Window 与 SurfaceView buffer transaction，FrameTimeline 也从 Android 12 起提供应用与 SurfaceFlinger expected/actual frame。混合页仍不能只靠一条 FrameTimeline：SurfaceView 等独立 stream 可能没有完整 app slice，TextureView 输入 frame 也要从第一套 BufferQueue 回溯。

### Android 13：两个容易混淆的变化

HWC HAL 从 Android 13 起以 AIDL 定义，旧 HIDL composer 版本被标记 deprecated。这个变化影响 HAL 接口和 vendor 实现，不改变 SF 仍需协商 DEVICE/CLIENT 的职责。

`AutoSingleLayer` 同样在 Android 13 成为默认配置，但官方限制正是“单 layer 简单 buffer update”。多 layer geometry/sync 场景不能借它绕过原子同步。

API 33 还公开 `SurfaceControl.Transaction.setBuffer()` 与 committed listener。`setBuffer()` 要求 HardwareBuffer 具备 composer overlay 与 GPU sampled image usage，因为系统可能选择硬件或 GPU 合成。

### Android 14：SurfaceSyncGroup 成为公开 API

`SurfaceSyncGroup` 可以收集 AttachedSurfaceControl、SurfacePackage 与附加 Transaction，等待子同步结果后应用合并 Transaction。它为跨进程嵌入式 UI 和多 Surface 提供公开协调工具。

同一版本的 SurfaceView 支持任意 alpha 并可选择跟随 visibility 或 attachment 的 Surface 生命周期。混合页面前后台、列表复用和半透明叠加的行为要按 API 34 规则检查。

### Android 15：调度目标与完成回调

API 35 增加 desired present time、transaction frame timeline 和 completed listener。三者分别表达期望显示时间、目标 VSync timeline 与 presented 后回调，不能互相替代。

Window、SurfaceView 和 SurfaceControl 还可表达 desired HDR headroom。该值是期望比例，最终范围受 buffer、display、环境和系统策略限制。

### Android 16：composition order

`SurfaceView.setCompositionOrder(int)` 公开后，多 SurfaceView 不必只依赖 `setZOrderOnTop()` 与 `setZOrderMediaOverlay()` 两个布尔入口。整数正负决定相对宿主上下，数值决定 peer 高低；相同数值顺序未定义。

### Android 17：本文当前对象

Android 17 的 SurfaceView 增加 blur region API；SurfaceFlinger 使用 FrontEnd 状态/snapshot，HWC 支持 present-or-validate 快路径，BLAST 继续处理 buffer transaction 与 release callback。本文所有调用名按固定 tag 解释，版本首引另由 API level 或历史 tag 证明。

### 固定版本来源

- [Android 12 `BLASTBufferQueue.cpp`](https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-12.0.0_r1/libs/gui/BLASTBufferQueue.cpp)、[Perfetto FrameTimeline](https://perfetto.dev/docs/data-sources/frametimeline)：确认现代基线；
- [Android 13 release notes](https://source.android.com/docs/whatsnew/android-13-release)、[AutoSingleLayer](https://source.android.com/docs/core/graphics/unsignaled-buffer-latch)、[API 33 Transaction](https://developer.android.com/reference/android/view/SurfaceControl.Transaction)：确认 HWC AIDL、latch 限制与公开 buffer API；
- [API 34 `SurfaceSyncGroup`](https://developer.android.com/reference/android/window/SurfaceSyncGroup)、[SurfaceView reference](https://developer.android.com/reference/android/view/SurfaceView)：确认同步组、lifecycle 与 alpha；
- [API 35 Transaction](https://developer.android.com/reference/android/view/SurfaceControl.Transaction)：确认 desired present、frame timeline、completed listener 与 HDR headroom；
- [Android 16 `SurfaceView.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-16.0.0_r1/core/java/android/view/SurfaceView.java)：确认 composition order；
- [Android 17 FrontEnd](https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-17.0.0_r1/services/surfaceflinger/FrontEnd/)、[`SurfaceView.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/core/java/android/view/SurfaceView.java)：确认本文当前实现。

## 10. 源码入口：Android 17 应该跟读哪里

### Platform：`android-17.0.0_r1`

| 核查点 | 一手来源 | 用来确认什么 |
|---|---|---|
| 宿主帧 | [AOSP `ViewRootImpl.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/core/java/android/view/ViewRootImpl.java)、[`Choreographer.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/core/java/android/view/Choreographer.java) | traversal/VSync 去重、宿主绘制与 window transaction |
| HWUI / Texture 回流 | [AOSP `DeferredLayerUpdater.cpp`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/libs/hwui/DeferredLayerUpdater.cpp)、[`DrawFrameTask.cpp`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/libs/hwui/renderthread/DrawFrameTask.cpp) | SurfaceTexture Consumer、AHardwareBuffer/SkImage、宿主 pending layer update |
| SurfaceView / BLAST | [AOSP `SurfaceView.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/core/java/android/view/SurfaceView.java)、[`BLASTBufferQueue.cpp`](https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-17.0.0_r1/libs/gui/BLASTBufferQueue.cpp) | container/BLAST child、几何、buffer transaction、frame-number merge |
| Transaction API | [AOSP `SurfaceControl.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/core/java/android/view/SurfaceControl.java)、[`SurfaceComposerClient.cpp`](https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-17.0.0_r1/libs/gui/SurfaceComposerClient.cpp) | multi-Surface 状态、buffer/fence、listeners、desired present、frame timeline |
| 跨 Surface 同步 | [AOSP `SurfaceSyncGroup.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/core/java/android/window/SurfaceSyncGroup.java) | child sync group、跨进程 SurfacePackage、merged transaction |
| SurfaceFlinger FrontEnd | [AOSP FrontEnd](https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-17.0.0_r1/services/surfaceflinger/FrontEnd/)、[`SurfaceFlinger.cpp`](https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-17.0.0_r1/services/surfaceflinger/SurfaceFlinger.cpp) | RequestedLayerState、lifecycle、snapshot、transaction readiness |
| Composition / HWC | [AOSP CompositionEngine](https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-17.0.0_r1/services/surfaceflinger/CompositionEngine/)、[`HWComposer.cpp`](https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-17.0.0_r1/services/surfaceflinger/DisplayHardware/HWComposer.cpp) | visible layer set、CLIENT target、validate/present 与 fences |

### Kernel：`android17-6.18-2026-06_r6`

- [`drivers/dma-buf/sync_file.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/drivers/dma-buf/sync_file.c)：sync fence fd；
- [`drivers/dma-buf/dma-fence.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/drivers/dma-buf/dma-fence.c)：signal、callback 与 wait；
- [`drivers/dma-buf/dma-buf.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/drivers/dma-buf/dma-buf.c)：dma-buf 共享对象的 attach/map 与引用管理入口。

kernel 公共源码不能说明 vendor GPU、codec、camera 或 DPU 的 fence 创建和 signal 原因。那部分要结合设备驱动与 vendor trace。

## 11. Perfetto 证据链：按对象复原一次混合显示

### 11.1 采集与对象清单

需要覆盖 app `gfx/view`、调度、SurfaceFlinger/layer/transactions/FrameTimeline、fence/sync、GPU，以及场景相关的 camera/codec/binder/vendor 数据源。只采应用 atrace，无法证明独立 layer 与 HWC 的状态。

开始分析时记录：目标进程/线程、宿主 App Window layer id、每个独立 container 与 buffer child、每个 SurfaceTexture 队列、Producer connection、几何 transaction、composition type 和 display token。

### 11.2 从目标 present 反向找输入

选定用户看到异常的 display frame，记录它的 present time 和 `display_frame_token`。随后列出该 display 的可见 layer：

1. 宿主 App Window 使用哪次 `BufferTX - <hostLayerName>`；
2. 每个独立 buffer layer 使用新 buffer 还是上次内容；
3. container position/crop/relative-Z 是否已经更新；
4. 哪些 layer 被判为 DEVICE，哪些进入 CLIENT；
5. client target 与 present fence 是否按 deadline 完成。

再向 Producer 方向回溯，比从最长 CPU slice 开始更容易定位错帧组合。

### 11.3 展开宿主 buffer 的内部来源

宿主 buffer 若包含 TextureView、WebView functor 或引擎纹理，还要继续拆：

- 外部 buffer 何时 queue；
- frame available / invalidate 何时进入宿主；
- RenderThread 本轮取得哪个 buffer；
- 外部 acquire fence 是否等待；
- 宿主 GPU 采样和 host `queueBuffer()` 何时完成。

SurfaceFlinger 只看到宿主 buffer，无法替分析者指出其中哪块 Texture 输入迟到。

### 11.4 对齐同步对象

每个“同步”结论都要注明机制：

| 观察到的机制 | 能证明什么 | 不能证明什么 |
|---|---|---|
| 同一 Transaction id | 该 Transaction 内状态原子应用 | 外部 Producer 的下一帧也在其中 |
| SurfaceSyncGroup 完成 | 已注册 child sync 都提供结果，merged transaction 可应用 | 未加入组的 codec/camera 逻辑帧 ready |
| committed listener | transaction applied，updates ready to be presented | display 已 present |
| completed listener | transaction 已 presented | panel 光学完成 |
| desired present time / frame timeline | SF 获得调度目标 | acquire fence 会在目标时间前 signal |
| AutoSingleLayer trace | 某次单 layer buffer update 允许 latch unsignaled | 多 layer 已同步 |

### 11.5 分开 FrameTimeline、BufferTX 与 fence

FrameTimeline 的宿主 SurfaceFrame 适合判断 App Window 是否按时完成，SF DisplayFrame 适合判断整屏 present。独立 Surface 或 SurfaceTexture 输入未必有完整 app actual slice。

`BufferTX - <layerName>` 只表示 SF server 侧 pending buffer transaction 数量。计数上升没有直接给出 acquire fence、sync barrier、desired present 或 HWC 状态。fence wait 也只描述依赖，要继续找到创建者。

### 11.6 HWC strategy 对比

发生功耗、GPU 或延迟跳变时，选择变化前后相邻 display frame，比较：

- 可见 layer 集合与 Z-order；
- 每个 layer 的 buffer format/dataspace/protected/alpha/transform/crop；
- DEVICE/CLIENT composition type；
- client target GPU 时长与面积；
- display mode、刷新率与 color mode；
- vendor Composer error、request 或 fallback。

同一页面静止与动画时可能使用不同 strategy。测试要覆盖出现问题的动态状态。

### 11.7 可复用排查顺序

1. 锁定异常 display present；
2. 建立本次可见 layer 和 parent/hierarchy；
3. 标记每个 layer 使用的新/旧 buffer 与几何状态；
4. 展开宿主内部的 Texture/引擎输入；
5. 对齐 Transaction、SurfaceSyncGroup 与 desired present；
6. 标明每个 acquire/release/present fence 的所有者；
7. 比较 HWC strategy 与 client target；
8. 回到最早偏离业务期望的 Producer 或同步边界。

## 12. 类型边界与故障模式

### 12.1 与单一 SurfaceView 页面

只有一个宿主和一个主要 SurfaceView 仍可用 SurfaceView 专项模型分析；当页面出现多个独立 Surface、Texture 回流、嵌入式 hierarchy 或需要跨对象同步时，混合模型更合适。分类依据是对象关系，不是控件数量。

### 12.2 与多窗口

混合出图通常发生在同一个 Window/hierarchy 内，多窗口则涉及多个 Window token、WindowState、焦点、insets、可见性和独立 App Window surface。一个页面也能同时属于两类，此时先按 Window 分组，再在每个 Window 内建立混合对象表。

### 12.3 与框架类型

Flutter、WebView、React Native、Camera 和游戏描述内容来源或框架。它们可能输出到宿主 App Window、TextureView、SurfaceView、SurfaceControl hierarchy 或多个目标。框架名不能直接决定混合拓扑。

### 12.4 故障模式

| 现象 | 首要检查 | 容易写错的结论 |
|---|---|---|
| 新字幕配旧视频帧 | 字幕所在宿主 buffer、视频 child buffer、目标 present | SF 应自动理解两者属于同一逻辑帧 |
| 视频已动，遮罩位置旧 | container geometry、host hole-punch、sync transaction | 视频 Producer 慢 |
| 地图标记与地图底图错位 | TextureView 输入 frame、宿主 acquire、标记所在 View frame | SurfaceFlinger 多 layer latch 错误 |
| 首屏部分黑 | 每个 Surface 生命周期、Producer connect、首 buffer、visibility | 页面主线程已画完，所以所有内容都应存在 |
| GPU 功耗突然升高 | DEVICE→CLIENT、client target、透明/transform/layer 集合 | layer 数增加必然线性增加 GPU 成本 |
| 某 Producer dequeue 很长 | 对应队列的 release fence 与 slot | 所有 Producer 都被同一个 display fence 阻塞 |
| Transaction committed 但画面未变 | completed/present、buffer readiness、目标 display | committed 等于 present |
| desired present 已设置仍迟到 | acquire fence、Producer cadence、排队顺序、display mode | API 会强制按指定纳秒显示 |
| AutoSingleLayer trace 出现 | 本次是否仅单 layer 简单 buffer update | 多 Surface 同步已经完成 |
| protected 视频黑屏 | secure/protected path、目标 display、HWC capability | 普通 RenderEngine fallback 可以解决 |

### Review 清单

1. 页面当前有哪些 Producer、Consumer 与最终 SF layer？
2. 宿主 buffer 内还包含哪些 Texture/引擎输入？
3. 每个独立 layer 的 container 与 buffer child 是否分开记录？
4. 几何、buffer、alpha、crop、Z-order 分别由哪笔 Transaction 更新？
5. 哪些对象加入 SurfaceSyncGroup，哪些没有？
6. 业务期望同步的内容是否来自可控制的 Producer？
7. acquire、release、present fence 是否标明队列与方向？
8. 目标 display frame 使用了每个 layer 的哪次新/旧内容？
9. HWC strategy 是否因动态属性或 layer 集合变化？
10. 平台、vendor、应用和框架版本是否固定并有对应证据？

## 总结

混合出图分析的单位是“内容对象”，不是应用进程或某一条 FrameTimeline。每个对象都要确认 Producer、Consumer、最终 SF layer、几何所有者、帧节奏、buffer 和 fence；宿主 buffer 内部还可能包含 TextureView 等二次输入。

同一 Transaction 负责其中状态的原子应用，`SurfaceSyncGroup` 等待加入组的 Surface，desired present/frame timeline 提供调度目标。Android 13 `AutoSingleLayer` 只适用于单 layer 简单 buffer update，不能完成跨 layer 同步。

Android 17 中，SurfaceFlinger FrontEnd 将多路 transaction 整理成状态与 snapshot，CompositionEngine/HWC 再处理整屏可见 layer 集合。定位错帧时，从异常 display present 反向列出每个 layer 使用的新旧 buffer 与几何状态，再回到最早偏离业务期望的 Producer 或同步边界。

GENERATED FILE - DO NOT EDIT.
Source: docs/rendering_pipelines/S06_multi_window_type.md
Source SHA-256: e180be5faeb94832ff4bff9647b9b5a8a24760b2de69a8d0f80729f1d29a9557

# Android Perfetto 系列 - App 出图类型 - 多窗口类型

多窗口分析要同时区分 Window、进程和 Display。两个窗口可以共享同一应用主线程与 RenderThread，也可以来自不同进程；它们还可能位于不同 Display，使用不同刷新节奏和 present fence。

Perfetto 排查从“每个窗口属于哪个 `ViewRootImpl`、哪个 Window/Task、哪个 SF layer、哪个 Display”开始。这个映射建立后，主线程串行、RenderThread 排队、窗口几何、Shell transition 和 HWC 资源竞争才有明确的责任对象。

<!--more-->

## 阅读导航

### 本文目录

- 阅读说明
- 1. 一帧完整流程：多个窗口怎样进入一个或多个 Display
- 2. 类型判定：窗口形态、执行拓扑与 Display 拓扑
- 3. 同进程多窗口：多个 ViewRootImpl 共享什么
- 4. 跨进程多窗口：哪些工作独立，哪些资源仍共享
- 5. WMS 与 Shell：Task、Window、leash 和 SurfaceControl
- 6. 生命周期、输入与 Insets：显示问题前的状态检查
- 7. 几何与 buffer 同步：resize、PiP 与 transition
- 8. SurfaceFlinger 与 HWC：按 Display 组织合成
- 9. 版本演进：Android 12 到 Android 17
- 10. 源码入口：Android 17 应该跟读哪里
- 11. Perfetto 证据链：按 Window 和 Display 复原一帧
- 12. 类型边界与故障模式
- 总结

### 系列文章目录

1. [Android Perfetto 系列 - App 出图类型 - 总览与识别方法](S01_rendering_types_overview.md)
2. [Android Perfetto 系列 - App 出图类型 - AOSP 标准类型](S02_aosp_standard_type.md)
3. [Android Perfetto 系列 - App 出图类型 - SurfaceView 类型](S03_surfaceview_type.md)
4. [Android Perfetto 系列 - App 出图类型 - TextureView 类型](S04_textureview_type.md)
5. [Android Perfetto 系列 - App 出图类型 - 混合出图类型](S05_mixed_rendering_type.md)
6. [Android Perfetto 系列 - App 出图类型 - 多窗口类型](S06_multi_window_type.md)
7. [Android Perfetto 系列 - App 出图类型 - Software / 离屏类型](S07_software_offscreen_type.md)
8. [Android Perfetto 系列 - App 出图类型 - Native Graphics 类型](S08_native_graphics_type.md)
9. [Android Perfetto 系列 - App 出图类型 - WebView 类型](S09_webview_type.md)
10. [Android Perfetto 系列 - App 出图类型 - Flutter 类型](S10_flutter_type.md)
11. [Android Perfetto 系列 - App 出图类型 - Camera 类型](S11_camera_type.md)
12. [Android Perfetto 系列 - App 出图类型 - Video Overlay / HWC 类型](S12_video_overlay_hwc_type.md)
13. [Android Perfetto 系列 - App 出图类型 - Game 类型](S13_game_type.md)
14. [Android Perfetto 系列 - App 出图类型 - React Native 类型](S14_react_native_type.md)

## 阅读说明

平台源码固定到 Android 17 / API 37 的 `android-17.0.0_r1`，kernel 源码固定到 `android17-6.18-2026-06_r6`。`ViewRootImpl`、Choreographer、HWUI RenderThread、WindowManager、WM Shell、SurfaceFlinger 和 HWC 的名称按平台 tag 核查；调度与 fence 的 kernel 机制按指定 kernel tag 核查。

多窗口包含 split screen、picture-in-picture（PiP）、freeform/desktop windowing、Dialog、PopupWindow、Activity Embedding、多 Display 与厂商自定义形态。用户看到的形态不能直接推出执行拓扑。本文所有结论都要落到 `pid/tid/Looper/ViewRootImpl/WindowState/SurfaceControl/displayId`。

版本演进以 Android 12 为起点，Android 12L 作为 API 32 的大屏节点单列。Android 17 大屏方向与可调整大小行为按 target 37 的官方规则解释；小屏、游戏豁免和厂商 windowing 配置仍要单独确认。

## 1. 一帧完整流程：多个窗口怎样进入一个或多个 Display

下面以“同一 Display 上的主应用 + PiP 视频 + 应用 Dialog”为例：

1. WindowManager 和 WM Shell 维护可见 Task、Activity、Window、transition leash、bounds、Z-order、focus 与 Insets。每个对象都归属于一个 `DisplayContent`。
2. 主应用窗口与同进程 Dialog 各有 `ViewRootImpl`。如果它们创建在同一 UI Looper，就共享该线程的 Choreographer；各自的 traversal callback 在同一 Looper 上串行执行。
3. PiP 若来自另一个进程，会使用另一个 UI Looper、Choreographer connection 和 HWUI RenderThread。两个进程的 pending frame 状态互不共享，但它们仍围绕同一个物理 Display 的调度与 present 周期工作。
4. 每个硬件加速窗口通常拥有自己的 `ThreadedRenderer`/`CanvasContext` 与 App Window Surface。相同进程里的多个 renderer 把任务投到进程级 HWUI RenderThread，任务按线程队列执行。
5. 每个窗口通过自己的 Surface/BLAST 提交窗口 buffer 和完成 fence。Dialog 轻量不代表没有独立窗口 buffer；是否独立要看 `ViewRootImpl`、WindowState 与 SF layer。
6. WMS/Shell 对 Task bounds、leash position/crop、visibility 与 windowing mode 的修改通过 `WindowContainerTransaction` 和 `SurfaceControl.Transaction` 进入相应层级。应用 buffer 更新来自各自 BLAST。
7. transition 或 resize 需要等待多窗口 draw 时，WMS 内部同步引擎收集参与 WindowContainer 的结果；应用和嵌入 Surface 还可能使用公开 `SurfaceSyncGroup`。未加入同步的 Producer 不会被自动等待。
8. SurfaceFlinger FrontEnd 接收窗口 buffer 与几何 transaction，更新 `RequestedLayerState` 和 `LayerSnapshot`。container/leash 的新几何与窗口 buffer 是两个状态来源。
9. SurfaceFlinger 按 Display 构造可见 layer 集合。没有新 buffer 的窗口可以继续显示上次内容；目标 transition 是否允许这种组合取决于同步约束。
10. 每个 Display 独立进入 CompositionEngine/HWC strategy。多个窗口的缩放、圆角、alpha、HDR/SDR、protected 属性和 overlay plane 占用共同决定 DEVICE/CLIENT。
11. `presentOrValidateDisplay()` 返回 `PresentSucceeded` 时该 Display 已执行 present 并保存 fences；其它分支处理 changes、可选 client composition 后调用 `presentAndGetReleaseFences()`。
12. 每个 Display 得到自己的 present fence，各窗口/层得到对应 release fence。窗口分布在两个 Display 时，不能用默认屏的一份 present fence 解释外接屏结果。

### 多窗口拓扑

这张图把同进程、跨进程和多 Display 分开。Perfetto 中需要找到图上每个窗口的 pid、ViewRoot、host layer 与 display id。

```mermaid
flowchart LR
    subgraph P1["Process A"]
        UIA["UI Looper + Choreographer"]
        VRA["ViewRoot A"]
        VRD["Dialog ViewRoot"]
        RTA["Process HWUI RenderThread"]
        UIA --> VRA
        UIA --> VRD
        VRA --> RTA
        VRD --> RTA
    end

    subgraph P2["Process B"]
        UIB["UI Looper + Choreographer"]
        VRB["PiP / App Window ViewRoot"]
        RTB["Process HWUI RenderThread"]
        UIB --> VRB --> RTB
    end

    RTA --> LA["Window A / Dialog<br/>independent BLAST buffers"]
    RTB --> LB["Window B<br/>independent BLAST buffer"]

    WMS["WMS / WM Shell<br/>Task, Window, leash, bounds"] --> TX["SurfaceControl transactions"]
    TX --> SF["SurfaceFlinger FrontEnd"]
    LA --> SF
    LB --> SF

    SF --> D0["Display 0 visible layer set"]
    SF --> D1["Display 1 visible layer set when present"]
    D0 --> H0["Composer HAL / Display driver 0"]
    D1 --> H1["Composer HAL / Display driver 1"]
    H0 --> P0["Display 0 present fence"]
    H1 --> P1F["Display 1 present fence"]
```

同进程窗口共享执行线程，不共享窗口 buffer。跨进程窗口的应用工作独立，仍在目标 Display 的 SF/HWC 阶段竞争 composition 资源。

### 同进程时序

该图描述两个 traversal 在同一 VSync callback 批次中都已到期的情况。callback 若在批次结束后才入队，会进入后续 frame。

```mermaid
sequenceDiagram
    participant UI as "App UI Looper"
    participant CH as "ThreadLocal Choreographer"
    participant A as "ViewRoot A"
    participant B as "ViewRoot B / Dialog"
    participant RT as "Process HWUI RenderThread"
    participant SF as "SF FrontEnd / CompositionEngine"
    participant HWC as "Composer HAL / Display driver"

    A->>CH: post traversal callback A
    B->>CH: post traversal callback B
    CH->>UI: doFrame callback phases
    UI->>A: traversal A
    A->>RT: syncAndDrawFrame A
    RT-->>UI: unblock when sync boundary permits
    UI->>B: traversal B
    B->>RT: syncAndDrawFrame B
    RT->>RT: draw/swap window A
    RT->>SF: host buffer transaction A
    RT->>RT: draw/swap window B
    RT->>SF: host buffer transaction B
    SF->>SF: 合入 WMS / Shell geometry<br/>选择 A/B buffer 与当前 snapshot
    SF->>HWC: 按目标 Display 提交可见 layer 集合
    HWC-->>SF: composition changes 或 PresentSucceeded
    opt 需要 CLIENT composition
        SF->>SF: RenderEngine 生成 client target
        SF->>HWC: setClientTarget
    end
    opt 当前轮尚未 present
        SF->>HWC: presentDisplay
    end
    HWC-->>SF: per-display present fence<br/>per-layer release fences
```

主线程在 `syncAndDrawFrame()` 后可能提前解除等待，但 RenderThread 仍只有一条任务队列。Window A 的 GPU/交换或 fence 路径占用 RenderThread 时，Window B 的 layer update 与 draw 会延后。

## 2. 类型判定：窗口形态、执行拓扑与 Display 拓扑

### 2.1 窗口形态

- split screen：多个 Task/Activity pane 同时可见；
- PiP：pinned windowing mode 的小窗与其它任务同屏；
- freeform/desktop：Task 可移动、缩放并带 caption/系统装饰；
- Dialog/Popup：通常由应用添加的独立顶层 window；
- Activity Embedding：一个 Task window 内使用 primary/secondary TaskFragment/Activity 容器；
- multi-display：窗口或 Task 位于不同 display id，可能各自有 SystemUI、focus 与 present。

形态只用于描述产品界面。执行拓扑还要继续判断。

### 2.2 执行拓扑

| 证据 | 拓扑判断 | 性能含义 |
|---|---|---|
| 同 pid、同 UI tid、多个 ViewRoot | 共享 UI Looper/Choreographer | traversal 与 callback 串行，任一窗口主线程工作会推迟后续 callback |
| 同 pid、多个 HWUI CanvasContext | 共享进程级 RenderThread | 多个 `DrawFrame`/layer update 在同一 RenderThread 队列执行 |
| 不同 pid | UI Looper 与 RenderThread 独立 | 应用 CPU 工作不直接串行，SF/HWC/内存带宽仍共享 |
| 不同 display id | 不同 display layer set/present | deadline、mode、color/HWC 能力和 present fence 要按 Display 分开 |

### 2.3 不能单独作为证据的现象

- 屏幕上有两个面板：可能是同一个窗口内的普通 View 双栏布局；
- layer tree 中有多个 layer：系统栏、壁纸、输入法本来就会存在；
- 同一进程有多个 `DrawFrame`：也可能是离屏 renderer 或其它 HWUI surface；
- 两个 Activity 同时可见：它们可能同进程，也可能通过 `android:process` 分到不同进程。

## 3. 同进程多窗口：多个 ViewRootImpl 共享什么

### 3.1 Choreographer 按 Looper 保存

`Choreographer` 使用 ThreadLocal。多个 `ViewRootImpl` 若创建在同一 UI 线程，会取得同一个 Choreographer 实例；它们分别向 `CALLBACK_TRAVERSAL` 队列提交 callback。

同一 `doFrame()` 会按 callback 类型执行到期任务。同类型 callback 也在 UI 线程串行运行。Window A 的 `performTraversals()` 超时，会占用 Window B callback 原本可用的 CPU 时间。

这条规则不能扩展成“同进程永远只有一个 Choreographer”。应用可以创建其它带 Looper 的线程，并在该线程取得 Choreographer；判断必须使用 Looper/tid。

### 3.2 ViewRootImpl 和窗口状态各自独立

每个顶层 window 有自己的 `ViewRootImpl`、AttachInfo、Insets 状态、dirty region、relayout 条件和 Surface。Dialog/Popup 是否很小，不改变它作为独立 window 的生命周期和 buffer 责任。

`performTraversals()` 也不保证每帧都调用 WMS。首帧、尺寸/可见性/LayoutParams/Insets 等状态要求 relayout 时，才通过 `IWindowSession` 进入 system_server。稳定绘制帧可以只更新应用内容。

### 3.3 RenderThread 是进程级共享执行者

Android 17 HWUI `RenderThread::getInstance()` 提供进程级 RenderThread。每个硬件窗口各有 renderer/CanvasContext，但 `DrawFrameTask` 和相关 layer update 进入同一 RenderThread 任务系统。

共享 RenderThread 带来三种常见影响：

- Window A 的 CPU render preparation 很长，Window B 任务排队；
- Window A 的 buffer dequeue/release wait 占用 RenderThread，后续窗口无法及时进入；
- Window A 提交大量 GPU 工作后，即便 Window B CPU task 很短，也可能受 GPU queue 与内存带宽影响。

CPU 任务串行与 GPU 执行依赖要分开。RenderThread slice 排队可以证明 CPU 侧顺序，GPU overlap/等待仍需 GPU 和 fence 轨迹。

### 3.4 每个窗口有独立 buffer 周转

共享主线程和 RenderThread 不会合并窗口 BufferQueue。Window A、Dialog B 与 Popup C 各自提交 host buffer，SurfaceFlinger 也按对应 layer 记录 `BufferTX - <layerName>`、buffer readiness 和 release callback。

一个窗口的 release fence 延迟只直接约束该窗口的 buffer 复用；它还可能通过共享 RenderThread 间接推迟其它窗口任务。

## 4. 跨进程多窗口：哪些工作独立，哪些资源仍共享

### 4.1 独立部分

不同进程各有：

- UI Looper、Choreographer pending frame 状态与 callback 队列；
- HWUI RenderThread 与应用 GPU submission；
- App Window Surface、BLAST/BufferQueue 与 release channel；
- 应用 FrameTimeline SurfaceFrame、GC、Binder pool 和调度状态。

来自同一 Display Scheduler 的 VSync 预测会经各自 connection 送到应用。两个进程可以一快一慢，也可以因 frame-rate override 使用不同内容更新频率；它们并不拥有两套物理 VSync。

### 4.2 共享部分

同一 Display 上的窗口共享：

- SurfaceFlinger transaction/layer 处理预算；
- CompositionEngine、RenderEngine client composition；
- HWC overlay plane、scaler、bandwidth 与 protected path；
- display mode、颜色模式、present deadline 和 panel；
- GPU、内存带宽、CPU/thermal/power 等设备资源。

所以 App A 的 `doFrame()` 正常不能证明整屏正常。App B 的 late buffer、Shell transition 或 HWC strategy 变化仍能让目标 DisplayFrame 迟到。

### 4.3 低帧率窗口可复用旧内容

PiP 视频可能按 24/30 fps 更新，主窗口可能按 60/90/120 Hz 更新。SurfaceFlinger 可以在多个 display frame 中复用 PiP 上次已选中的 buffer。复用符合帧率设计，不能按“PiP 每个 VSync 都没有 BufferTX”判为丢帧。

要检查的是视频 timestamp、目标 display period、实际 buffer 选择和用户观察到的 cadence 是否一致。

## 5. WMS 与 Shell：Task、Window、leash 和 SurfaceControl

### 5.1 WMS 逻辑层级

Android 17 的窗口管理对象包括：

- `RootWindowContainer` / `DisplayContent`：按 Display 组织窗口与 policy；
- `DisplayArea` / `TaskDisplayArea`：显示区域与 Task 容器；
- `Task` / `TaskFragment`：windowing mode、bounds、Activity 分组；
- `ActivityRecord` / `WindowToken` / `WindowState`：Activity 和具体应用窗口；
- `WindowContainer`：多种 WMS 容器的共同层级抽象。

这是一棵逻辑管理树，不应机械等同于 SurfaceFlinger layer tree。transition 可以创建 leash 并临时 reparent surface，container/effect layer 也会让两棵树的节点数量不同。

### 5.2 WindowContainerTransaction 与 SurfaceControl.Transaction

`WindowContainerTransaction`（WCT）描述 WindowContainer 的高层变化，例如 bounds、windowing mode、TaskFragment 或 hierarchy 操作。WindowOrganizer/WM Shell 将 WCT 交给 system_server。

WMS/Shell 再通过 `SurfaceControl.Transaction` 更新具体 layer 的 position、crop、matrix、alpha、Z-order、visibility 与 reparent。WCT 不是 buffer transaction，也不携带应用下一块 App Window buffer。

下面的职责示意用于区分两类 transaction。它不是可编译代码。

```text
WindowContainerTransaction
  setBounds(task or taskFragment)
  setWindowingMode(...)
  hierarchy / reparent operation
  apply through WindowOrganizer / system_server

SurfaceControl.Transaction
  setPosition(leash or window surface)
  setCrop(...)
  setMatrix(...)
  setAlpha(...)
  show / hide / reparent
  原子应用 layer 状态

App BLAST buffer transaction
  setBuffer(app window layer, buffer, acquire fence, frame number)
```

WCT 改变管理状态，SurfaceControl transaction 改变合成层状态，BLAST transaction 提交应用内容。resize 和 transition 出错时要分别找证据。

### 5.3 transition leash

Shell transition 常把 Task/Activity/window surface reparent 到临时 leash，由 transition handler 对 leash 做动画。动画期间看到 position/crop/alpha 落在 leash 上，不代表 child App Window 没有 geometry。

分析 layer tree 时要保留 parent chain。只按 layer name 找 App Window，容易漏掉实际控制它的 transition leash。

## 6. 生命周期、输入与 Insets：显示问题前的状态检查

### 6.1 Window 生命周期

窗口创建、attach、relayout、visibility、surface replacement 与 remove 会改变 ViewRoot、WindowState、SurfaceControl 和 layer id。Dialog 快速开关、Popup anchor 离开、Activity 进入 PiP、Display 移除都可能让旧对象失效。

跨生命周期 trace 应拆段。相同 layer name 不保证 layer id、BufferQueue 与 window token 相同。

### 6.2 focus 与输入目标

用户看到窗口却没有输入响应时，问题可能在 input focus/touchable region，而非绘制。多窗口要记录：

- 当前 focused window 与 focused app；
- input window handle、touchable region 与 transform；
- PiP/embedded window 是否允许输入；
- 不同 Display 的 focus policy 与输入设备路由。

InputDispatcher 与 WMS 窗口状态能证明输入发给谁；`doFrame()` 是否运行只能证明某个窗口在绘制。

### 6.3 Insets 与 IME

状态栏、导航栏、caption、display cutout 和 IME 可能分别由系统窗口或 leash 表示。Insets 变化会触发应用 traversal，也会伴随 Shell/WMS SurfaceControl transaction。

键盘弹出时出现窗口 resize、平移或内容遮挡，要同时对齐：

- Insets source/control 与 animation；
- 应用 `WindowInsets` dispatch 和 traversal；
- IME window/leash geometry；
- App Window buffer size/crop 与 SF layer 状态。

只看 IME 进程或应用 layout 都不能覆盖完整路径。

## 7. 几何与 buffer 同步：resize、PiP 与 transition

### 7.1 几何和内容是两个输入

Task/window bounds、leash position/crop 与 App Window buffer size 来自不同模块。系统需要在 transition 中决定何时显示新 bounds、何时等待应用 draw、何时允许旧 buffer 被缩放或 letterbox。

常见组合包括：

- 新 geometry + 旧 buffer：过渡期缩放旧内容；
- 新 geometry + 新 buffer：resize draw 已赶上；
- 旧 geometry + 新 buffer：应用已按新配置画，但 layer 状态尚未切换时会出现错误组合；
- snapshot/splash/starting window：系统用替代 layer 覆盖应用重绘间隙。

其中哪些组合被允许，取决于 transition/sync 设计。不能用“只要一边没 ready 就一定阻塞整个 Display”解释。

### 7.2 WMS 内部同步与公开 SurfaceSyncGroup

WMS 的 `BLASTSyncEngine` 用于等待一组 WindowContainer 的 draw/surface transaction，再通过 ready callback 交给 transition 或调用方。它是 system_server 内部机制。

API 34 `SurfaceSyncGroup` 面向应用与嵌入 Surface，支持 `AttachedSurfaceControl`、`SurfaceControlViewHost.SurfacePackage` 和附加 Transaction。两者名称都带 sync，但 API、参与对象和调用方不同。

同步机制只等待注册对象。Camera、codec 或引擎 Producer 的逻辑下一帧若没有通过受控 Surface 进入同步，系统不能替它建立业务时刻关系。

### 7.3 AutoSingleLayer 不负责跨窗口同步

Android 13 `AutoSingleLayer` 仅允许单 layer 的简单 buffer update 在特定条件下 latch unsignaled buffer。官方文档排除跨 layer、几何变化和 sync transaction。

resize、PiP、分屏拖拽和 transition 常包含多个 layer 与 geometry，因此不能把 `AutoSingleLayer` 当成多窗口同步或“局部推进其它窗口”的机制。它只可能作用于某次满足单 layer 限制的 buffer update。

### 7.4 relayout 只在条件命中时跨 Binder

`ViewRootImpl.performTraversals()` 会根据首帧、尺寸/可见性、Insets、LayoutParams 和强制 relayout 等状态决定是否调用 `IWindowSession.relayout()`。稳定帧不必每次进入 WMS。

看到 `relayoutWindow`、WMS surface placement 与应用 traversal 同时变长时，检查 Binder 排队、system_server 锁/线程、DisplayContent surface placement 和返回的 surface/bounds；没有 relayout slice 时，不要把普通绘制超时归给 WMS。

## 8. SurfaceFlinger 与 HWC：按 Display 组织合成

### 8.1 FrontEnd 按 layer 处理，Output 按 Display 处理

SurfaceFlinger FrontEnd 接收各窗口和 Shell/WMS transaction，更新 layer 状态、hierarchy 和 snapshot。CompositionEngine 为每个 Output/Display 构造可见 layer 集合。

同一个 layer 可能经过 mirror、virtual display 或 display-specific projection 出现在不同 Output；分析时要用目标 Display 的 Output layer 状态，不能只看全局 layer 是否存在。

### 8.2 buffer、geometry 与 present 要分开

| 信号 | 粒度 | 能回答什么 |
|---|---|---|
| `BufferTX - <layerName>` | buffer layer | SF server 有多少 pending buffer transaction |
| SurfaceControl 状态 | container/leash/window layer | position、crop、alpha、Z、visibility、reparent |
| acquire fence | 单块 buffer | Producer 写入何时完成 |
| release fence | 被消费的 layer/buffer | 旧 buffer 何时能复用 |
| present fence | 单个 Display present | 该 Display 的 present 工作何时到达显示栈完成边界 |

present fence 不属于某个 Window。两个物理 Display 各有 present；mirror/virtual display 还要确认具体 Output 和 fence 语义。

### 8.3 HWC 评估整个 Display 的 layer 集合

影响 DEVICE/CLIENT 的条件包括：

- 可用 overlay plane、scaler、bandwidth 与 vendor 限制；
- 每个窗口的 buffer format、dataspace、HDR metadata 与 protected usage；
- transition leash 的 scale、rotation、alpha、crop 与 rounded corner；
- 多窗口遮挡、dim、caption、SystemUI 与 IME；
- Display mode、resolution、color mode 与全局 transform。

窗口多不保证 client composition，单个复杂窗口也可能触发 CLIENT。比较 HWC strategy 时要记录整个可见集合和变化的 layer 属性。

### 8.4 protected 与 secure 不能混为一谈

`FLAG_SECURE` 约束截图、录屏和非安全 Display；protected buffer usage 要求硬件保护的读取与显示路径。两者可能同时出现，但不是同一个标志。

protected 视频与普通窗口同屏时，HWC 可能重分配 plane 或让普通 layer 进入 CLIENT，为受保护 layer 保留硬件路径。设备无法满足保护要求时可能黑屏或拒绝显示，不能把 protected buffer 交给普通非保护 RenderEngine。

### 8.5 present 流程

Android 17 的 HWC 分支可简化为下面的职责顺序。这是概念示意，不是可编译调用栈。

```text
for each target display
  向 HWC 提交可见 layer 状态
  if skip-validate conditions allow
    presentOrValidateDisplay()
    if PresentSucceeded
      use saved present/release fences
      stop; do not present again
  validate result
  read composition changes and display requests
  acceptChanges()
  if any CLIENT layer
    RenderEngine draws client target
    setClientTarget(output acquire fence)
  presentAndGetReleaseFences()
```

`PresentSucceeded` 表示 HAL 组合调用走了 present 分支，不表示 panel 扫描或光学响应完成。

## 9. 版本演进：Android 12 到 Android 17

| 平台 | 多窗口相关变化 | 对 Review 的影响 |
|---|---|---|
| Android 12 / API 31 | 现代 BLAST/FrameTimeline 基线；大屏与 foldable 已广泛使用多窗口 | 窗口 buffer、SF layer 与 DisplayFrame 可按现代路径分析 |
| Android 12L / API 32 | 大屏系统体验增强；Activity Embedding 在多数 Android 12L+ 大屏设备受支持 | 一个 Task window 可并列 primary/secondary Activity container；运行时仍要查询 split support |
| Android 13 / API 33 | HWC HAL 以 AIDL 定义；`AutoSingleLayer` 默认启用但排除跨 layer/geometry/sync | HAL 接口变化不改 HWC 职责；不能用 unsignaled latch 解释多窗口同步 |
| Android 14 / API 34 | `SurfaceSyncGroup` 成为公开 API，适用于 AttachedSurfaceControl 与 SurfacePackage 等 | 应用/跨进程嵌入 Surface 可显式收集同步结果；WMS 内部仍有独立 sync engine |
| Android 15 / API 35 | edge-to-edge 对 target 35 应用成为重要窗口/Insets 行为；Transaction desired present/frame timeline/completed listener 公开 | 多窗口 resize/IME/caption 测试要覆盖新的 Insets/内容区域；调度 API 不会消除 buffer fence |
| Android 16 / API 36 | OEM 可支持 desktop windowing；target 36 大屏应用的方向、宽高比和 resizability 限制被系统忽略，但存在 opt-out 阶段 | 大屏更频繁进入 resize/旋转/freeform；应用必须处理配置和 window bounds 变化 |
| Android 17 / API 37 | target 37、`sw ≥ 600dp` 时移除上述开发者 opt-out；小于 600dp 与 game category 豁免 | 不可调整大小/固定方向不能再作为大屏布局前提；trace 中 relayout/config/transition 增加不代表 SF 管线换代 |

### Android 12 与 12L

Android 12 已具备本文使用的 BLAST 和 FrameTimeline 基线。Android 12L 面向大屏优化系统 UI、多任务和兼容体验；Jetpack WindowManager Activity Embedding 在多数 Android 12L/API 32 及以上大屏设备受支持，也可能由厂商扩展到更低版本。

Activity Embedding 是 split task window：primary/secondary container 持有 Activity。它不等于两个独立应用进程，也不保证两个 Activity 使用不同主线程。运行时应查询 `SplitController` support，并从实际 pid/tid/ViewRoot 验证。

### Android 13

Android 13 将 HWC HAL 定义转向 AIDL，同时引入默认 `AutoSingleLayer` 配置。HWC AIDL 改变 framework/vendor 接口，SurfaceFlinger 仍要为每个 Display 协商 composition strategy。

`AutoSingleLayer` 的官方限制对多窗口格外重要：只处理单 layer 简单 buffer update，跨 layer、几何和 sync transaction 不适用。

### Android 14

API 34 的 `SurfaceSyncGroup` 让应用和跨进程嵌入 hierarchy 能收集多个 Surface 的同步 transaction。WindowManager transition 自己使用 system_server 内部同步组件，二者不能按同一个 API 解释。

### Android 15

target 35 的 edge-to-edge 行为会改变内容区域与系统栏处理，多窗口、IME、caption 和 cutout 场景可能触发不同 Insets/layout 工作。它不创建新的 App Window Producer，页面仍按实际 Window/Surface 拓扑分类。

API 35 的 desired present、frame timeline 和 completed listener 可补充 SurfaceControl transaction 的调度与完成证据；acquire fence 和 Display 能力仍是硬约束。

### Android 16

Android 16 允许 OEM 配置 desktop windowing，freeform、caption、任务缩放、外接 Display 和桌面 workspace 进入系统实现范围。具体设备是否启用由资源 overlay、设备能力和厂商配置决定。

对 target 36 的应用，大屏会忽略限制方向、宽高比和 resizability 的属性/API；该阶段仍提供开发者 opt-out。测试应覆盖 `sw ≥ 600dp`、旋转、resize、折叠状态和 freeform bounds。

### Android 17

Android 17 对 target 37 移除 Android 16 的 opt-out。大屏上 `screenOrientation`、`setRequestedOrientation()` 的固定方向值、`resizeableActivity`、`minAspectRatio` 与 `maxAspectRatio` 会被忽略。小于 600dp 的屏幕和按 `android:appCategory` 分类的游戏不受该规则影响。

Android 官方说明这一步没有引入另一套方向/resize 机制，变化是 opt-out 不再可用。渲染 Review 要关注应用对 configuration、bounds、资源与状态保存的处理；SurfaceFlinger/BLAST 主路径仍按 Android 17 固定源码分析。

### 固定版本来源

- [AOSP multi-window](https://source.android.com/docs/core/display/multi-window)、[multi-display overview](https://source.android.com/docs/core/display/multi_display)：确认 windowing mode 与 Display 组织；
- [Activity Embedding](https://developer.android.com/develop/ui/views/layout/activity-embedding)：确认 Android 12L/API 32 支持和运行时查询；
- [Android 13 release notes](https://source.android.com/docs/whatsnew/android-13-release)、[AutoSingleLayer](https://source.android.com/docs/core/graphics/unsignaled-buffer-latch)：确认 HWC AIDL 与适用限制；
- [API 34 `SurfaceSyncGroup`](https://developer.android.com/reference/android/window/SurfaceSyncGroup)：确认公开同步对象；
- [Android 15 edge-to-edge](https://developer.android.com/develop/ui/views/layout/edge-to-edge)：确认 target 35 Insets/内容区域行为；
- [Android 16 summary](https://developer.android.com/about/versions/16/summary)、[AOSP desktop windowing](https://source.android.com/docs/core/display/multi-window#desktop-windowing)：确认 API 36 大屏与 OEM desktop 配置；
- [Android 17 release notes](https://developer.android.com/about/versions/17/release-notes)、[resizability guidance](https://developer.android.com/blog/posts/prepare-your-app-for-the-resizability-and-orientation-changes-in-android-17)：确认 target 37 opt-out 移除与豁免。

## 10. 源码入口：Android 17 应该跟读哪里

### App / HWUI

| 核查点 | 一手来源 | 用来确认什么 |
|---|---|---|
| 每窗口 ViewRoot | [AOSP `ViewRootImpl.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/core/java/android/view/ViewRootImpl.java) | traversal、relayout 条件、draw、App Window Surface |
| Looper 帧调度 | [AOSP `Choreographer.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/core/java/android/view/Choreographer.java) | ThreadLocal、callback 队列、VSync pending 状态 |
| 进程级 RenderThread | [AOSP `RenderThread.cpp`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/libs/hwui/renderthread/RenderThread.cpp)、[`DrawFrameTask.cpp`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/libs/hwui/renderthread/DrawFrameTask.cpp) | singleton、任务队列、UI unblock 与 draw/swap |
| 窗口 buffer | [AOSP `BLASTBufferQueue.cpp`](https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-17.0.0_r1/libs/gui/BLASTBufferQueue.cpp) | 每窗口 buffer transaction、release callback |

### WindowManager / Shell

| 核查点 | 一手来源 | 用来确认什么 |
|---|---|---|
| WindowContainer 层级 | [AOSP `WindowContainer.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/services/core/java/com/android/server/wm/WindowContainer.java)、[`DisplayContent.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/services/core/java/com/android/server/wm/DisplayContent.java) | Display/Task/Activity/Window 组织与 SurfaceControl |
| 具体窗口 | [AOSP `WindowState.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/services/core/java/com/android/server/wm/WindowState.java) | relayout、surface position、visibility、Insets/input 关系 |
| Task / TaskFragment | [AOSP `Task.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/services/core/java/com/android/server/wm/Task.java)、[`TaskFragment.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/services/core/java/com/android/server/wm/TaskFragment.java) | bounds、windowing mode、Activity Embedding container |
| WindowContainerTransaction | [AOSP `WindowContainerTransaction.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/core/java/android/window/WindowContainerTransaction.java) | organizer 传递的高层 window/container 变更 |
| WMS 内部 sync | [AOSP `BLASTSyncEngine.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/services/core/java/com/android/server/wm/BLASTSyncEngine.java) | WindowContainer draw/transaction 收集、ready 与回调 |
| Transition | [AOSP `TransitionController.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/services/core/java/com/android/server/wm/TransitionController.java) | transition 收集、sync、Shell handoff |

### SurfaceFlinger / Display

| 核查点 | 一手来源 | 用来确认什么 |
|---|---|---|
| SurfaceControl 状态 | [AOSP `SurfaceControl.java`](https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/core/java/android/view/SurfaceControl.java)、[`SurfaceComposerClient.cpp`](https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-17.0.0_r1/libs/gui/SurfaceComposerClient.cpp) | position/crop/reparent/buffer/fence transaction |
| FrontEnd | [AOSP FrontEnd](https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-17.0.0_r1/services/surfaceflinger/FrontEnd/)、[`SurfaceFlinger.cpp`](https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-17.0.0_r1/services/surfaceflinger/SurfaceFlinger.cpp) | 状态、snapshot、transaction readiness、per-display output |
| Composition / HWC | [AOSP CompositionEngine](https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-17.0.0_r1/services/surfaceflinger/CompositionEngine/)、[`HWComposer.cpp`](https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-17.0.0_r1/services/surfaceflinger/DisplayHardware/HWComposer.cpp) | output layer、DEVICE/CLIENT、validate/present/fences |

### Kernel：`android17-6.18-2026-06_r6`

- [`kernel/sched/core.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/kernel/sched/core.c)、[`kernel/cgroup/cpuset.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/kernel/cgroup/cpuset.c)：多个应用/UI/RenderThread 的调度与 cpuset 约束；
- [`drivers/dma-buf/sync_file.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/drivers/dma-buf/sync_file.c)、[`drivers/dma-buf/dma-fence.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/drivers/dma-buf/dma-fence.c)：窗口 buffer fence fd、signal 与 wait。

公共 kernel 源码不能解释某台设备的 HWC plane、DPU、GPU 或 Display driver 延迟。设备结论仍要结合 vendor trace 与驱动。

## 11. Perfetto 证据链：按 Window 和 Display 复原一帧

### 11.1 按 Display 分组

记录目标 `displayId`、刷新率/mode、物理或虚拟类型、分辨率、color mode 与 present timeline。窗口跨 Display 时分别选目标 DisplayFrame，不要把时间线合成一条。

### 11.2 建立 Window 表

| 字段 | 记录内容 |
|---|---|
| 归属 | uid、pid、package、Activity/Dialog/Popup/PiP/SystemUI |
| 执行 | UI tid/Looper、Choreographer、RenderThread tid、ViewRoot identity |
| WMS | displayId、Task/TaskFragment、WindowToken/WindowState、windowing mode、bounds |
| SF | container/leash/buffer layer id、parent、Z、crop、visibility |
| Buffer | BLAST/BufferQueue 名、BufferTX counter、frame number、fence |
| FrameTimeline | SurfaceFrame token、DisplayFrame token、layer name、present type |

Window 表能直接发现“同名窗口已重建”“Dialog 与主窗共享线程”“PiP 实际在另一 Display”等问题。

### 11.3 同进程：按 UI 和 RenderThread 队列排序

在 UI tid 上列出目标 `doFrame()` 中所有 traversal callback、`performTraversals()`、relayout Binder 调用和 `syncAndDrawFrame()`。按开始顺序判断哪个窗口占用时间，不能只找最长 slice。

再到进程 RenderThread 列出每个 CanvasContext/窗口的 `DrawFrame`、dequeue、GPU submit 与 queue。Window B 开始晚可能只是排在 Window A 后面；Window B 自己的 draw duration 短，仍会错过 deadline。

### 11.4 跨进程：分别完成应用侧判断

对每个应用检查：

- 是否按本窗口 expected timeline 起帧；
- main/RenderThread/GPU 是否按时提交；
- App Window `BufferTX` 是否进入 SF；
- acquire fence 与 release backpressure 是否属于本窗口。

之后再进入同一 Display 的 SF/HWC。如果两个应用都按时提交而 DisplayFrame 迟到，重点转向 Shell geometry、SurfaceFlinger、client composition、HWC 和 display。

### 11.5 对齐 WMS/Shell transaction

窗口移动、resize、PiP 或 transition 期间记录：

1. WCT 的 bounds/windowing mode/hierarchy 变化；
2. WMS `BLASTSyncEngine` sync id 与参与 WindowContainer；
3. Shell transition id、leash 创建/reparent 与动画 transaction；
4. 应用 relayout/configuration/traversal 与新 buffer；
5. SF 中 geometry 和 buffer 各自生效的 display frame。

若 system_server/Shell 密集 transaction 与应用重绘并发，Binder 和 surface transaction flow 能证明等待位置。单凭窗口抖动录像无法区分应用 layout 与 leash animation。

### 11.6 检查 HWC 与 present

按目标 Display 比较相邻帧的 visible layer set、DEVICE/CLIENT、client target、protected layer、display mode 和 present fence。Dialog、caption、IME、dim 或 transition leash 出现后 composition type 改变，往往比单个应用 `doFrame` 更能解释 GPU/功耗跳变。

present fence 只给 Android 显示栈边界。触摸到光子、panel scanout 或外接 Display 设备延迟需要额外测量。

### 11.7 可复用排查顺序

1. 选择目标 Display 和异常 present；
2. 列出该 Display 的 Window、leash 与可见 SF layer；
3. 标记每个 Window 的 pid/UI tid/RenderThread/ViewRoot；
4. 同进程窗口检查 callback 与 RenderThread 串行；
5. 跨进程窗口分别检查应用提交；
6. 对齐 WCT、sync id、transition leash 与 relayout；
7. 检查每个窗口 buffer、geometry、fence 和新旧选择；
8. 比较 HWC strategy，定位最早偏离目标 frame 的对象。

## 12. 类型边界与故障模式

### 12.1 与双栏 View 布局

同一个 Activity/Window 内用 RecyclerView、Compose 或 SlidingPaneLayout 做双栏，仍可能只有一个 ViewRoot 和 App Window buffer。这是单窗口布局，不应因为视觉上有两个 pane 就按多窗口分析。

### 12.2 与混合出图

混合出图区分多个内容 Producer/Consumer；多窗口区分多个顶层 Window/WindowContainer/Display。一个 Window 内可以混合 SurfaceView/TextureView，一个多窗口页面里的每个 Window 也可以各自混合出图。分析顺序是按 Display→Window 分组，再展开 Window 内的内容对象。

### 12.3 与多 Display

多窗口可以发生在一个 Display，多 Display 也可能每屏只有一个窗口。进入多个 display id 后，必须分别处理刷新率、色彩、HWC capability、focus、SystemUI 和 present fence。

### 12.4 故障模式

| 现象 | 首要检查 | 容易写错的结论 |
|---|---|---|
| Dialog 出现后主窗卡顿 | 同 UI callback 顺序、共享 RenderThread、HWC layer 集合 | Dialog 小，不可能影响主窗 |
| PiP 流畅而主窗卡 | 两个进程各自 frame、主窗提交、SF/HWC | PiP 抢了应用主线程 |
| 分屏拖拽出现黑边 | WCT/bounds、sync、应用 resize draw、leash crop、旧 buffer 缩放 | 应用没有画任何内容 |
| 窗口位置跳一下 | Shell leash animation 与 child geometry、生效的 display frame | App `layout()` 计算错 |
| 同进程 Window B 总晚 | UI traversal 顺序、RenderThread queue、Window A fence wait | Window B 自己 draw 太慢 |
| 外接屏晚、内屏正常 | displayId、mode、HWC/output、每屏 present fence | 同一进程帧应同时显示 |
| `BufferTX` 只在一个窗口积压 | 对应 layer fence/readiness/release channel | 整个进程 BufferQueue 都堵塞 |
| AutoSingleLayer trace 出现 | 是否单 layer 简单 buffer update | 多窗口同步已完成 |
| protected PiP 黑屏 | secure/protected path、目标 Display 能力、HWC | 普通 GPU client composition 可回退 |
| target 37 大屏布局突变 | resize/orientation 限制被忽略、configuration/Insets | Android 17 换了 SF 管线 |

### Review 清单

1. 问题发生在哪个 `displayId`，目标 present fence 属于哪一屏？
2. 屏幕上每个可见 pane 是普通 View、Activity container 还是独立 Window？
3. 每个 Window 的 pid、UI tid、ViewRoot 和 RenderThread 是什么？
4. 同进程 traversal 与 DrawFrame 的实际出队顺序是什么？
5. WMS 逻辑 parent 与 SF layer parent/leash 是否都已记录？
6. 本轮是否发生 relayout、configuration、Insets 或 transition？
7. geometry transaction 和 App Window buffer 分别在哪个 DisplayFrame 生效？
8. acquire/release/present fence 是否按 Window/Display 标明？
9. HWC strategy 是否因 caption、IME、leash、HDR 或 protected layer 改变？
10. Android target、屏幕 `sw`、game category 与 desktop/multi-window 设备配置是否确认？

## 总结

多窗口分析的第一层分组是 Display，第二层是 Window，第三层才是进程和内容 Producer。同一 UI Looper 上的多个 ViewRoot 共享 Choreographer callback 队列，同进程硬件窗口共享进程级 RenderThread；每个窗口仍有独立 Surface/BLAST 与 SF buffer layer。

跨进程窗口拥有独立应用帧执行，但同一 Display 的 SurfaceFlinger、HWC、overlay、client target、带宽和 present deadline 仍然共享。WMS/WCT 管理 Task/Window 状态，SurfaceControl transaction 管理 layer 几何，应用 BLAST 提交窗口内容，三者要分别对齐。

Android 17 对 target 37 大屏应用移除了方向、宽高比和 resizability opt-out，增加了应用遇到 resize/configuration/transition 的概率，没有替换 BLAST 或 SurfaceFlinger 显示主线。定位问题时，从目标 Display present 反向列出 Window、leash、buffer 和几何，再回到最早迟到的 UI/RenderThread、WMS/Shell 同步或 HWC 阶段。

GENERATED FILE - DO NOT EDIT.
Source: docs/rendering_pipelines/S07_software_offscreen_type.md
Source SHA-256: 574e42119ec2f7761dfeb4ca4d46dc07d45f71140d0d0012d13c16e4982a1d94

# Android Perfetto 系列 - App 出图类型 - Software / 离屏类型

Software rendering（软件渲染）描述“谁来生成像素”，offscreen rendering（离屏渲染）描述“像素先写到哪里”。两者是正交维度：CPU 可以直接写可见 `Surface`，GPU 也可以先画进离屏纹理或 `HardwareBuffer`。如果只凭“没看到 `DrawFrame`”或“出现了一块中间 buffer”判断路径，很容易把生产者、消费者和最终显示对象混在一起。

这篇文章以 Android 17 / API 37、`android-17.0.0_r1` 为平台源码锚点，kernel 侧以 `android17-6.18-2026-06_r6` 为锚点。分析目标是回答四个问题：谁生成像素，像素写到哪里，谁消费结果，结果有没有进入显示链路。

<!--more-->

## 阅读导航

### 本文目录

- 1. 两个维度：生产方式与结果去向
- 2. CPU 直接写可见 Surface
- 3. View 的 software layer
- 4. GPU 与 HardwareBuffer 离屏渲染
- 5. SurfaceControl.setBuffer 直接提交
- 6. 调度、fence 与 buffer 生命周期
- 7. Perfetto 证据链
- 8. 性能成本与内存压力
- 9. Android 12—17 版本演进
- 10. Android 17 源码入口
- 11. 类型边界与常见误判
- 总结

### 系列文章目录

1. [Android Perfetto 系列 - App 出图类型 - 总览与识别方法](S01_rendering_types_overview.md)
2. [Android Perfetto 系列 - App 出图类型 - AOSP 标准类型](S02_aosp_standard_type.md)
3. [Android Perfetto 系列 - App 出图类型 - SurfaceView 类型](S03_surfaceview_type.md)
4. [Android Perfetto 系列 - App 出图类型 - TextureView 类型](S04_textureview_type.md)
5. [Android Perfetto 系列 - App 出图类型 - 混合出图类型](S05_mixed_rendering_type.md)
6. [Android Perfetto 系列 - App 出图类型 - 多窗口类型](S06_multi_window_type.md)
7. [Android Perfetto 系列 - App 出图类型 - Software / 离屏类型](S07_software_offscreen_type.md)
8. [Android Perfetto 系列 - App 出图类型 - Native Graphics 类型](S08_native_graphics_type.md)
9. [Android Perfetto 系列 - App 出图类型 - WebView 类型](S09_webview_type.md)
10. [Android Perfetto 系列 - App 出图类型 - Flutter 类型](S10_flutter_type.md)
11. [Android Perfetto 系列 - App 出图类型 - Camera 类型](S11_camera_type.md)
12. [Android Perfetto 系列 - App 出图类型 - Video Overlay / HWC 类型](S12_video_overlay_hwc_type.md)
13. [Android Perfetto 系列 - App 出图类型 - Game 类型](S13_game_type.md)
14. [Android Perfetto 系列 - App 出图类型 - React Native 类型](S14_react_native_type.md)

## 1. 两个维度：生产方式与结果去向

第一维是像素生产方式。

- CPU software：CPU 通过 `Canvas`、Bitmap 栅格化或直接内存写入生成像素。
- HWUI / GPU：HWUI、Skia、OpenGL ES 或 Vulkan 把绘制命令交给 GPU。
- 外部硬件：相机、视频解码器等硬件模块写入 buffer。它们属于更专门的 Camera、Video 类型，本篇只用来说明分类边界。

第二维是输出位置。

- 直接可见：结果就是某个可见 `Surface` 的下一块 buffer，提交后可以进入 SurfaceFlinger。
- 中间结果：先写入 Bitmap、GPU render target、FBO、`HardwareBuffer` 或 `ImageReader`，稍后由窗口、编码器、算法模块或 `SurfaceControl` 消费。

把两个维度组合起来，常见路径可以收敛为下表。

| 生产者 | 输出 | 最终可见对象 | 典型入口 |
|---|---|---|---|
| CPU | 可见 Surface buffer | 当前窗口或独立 Surface layer | `ViewRootImpl.drawSoftware()`、`Surface.lockCanvas()` |
| CPU | Bitmap 中间结果 | 宿主窗口 layer | `LAYER_TYPE_SOFTWARE`、自建 Bitmap 缓存 |
| HWUI / GPU | GPU 中间目标或 `HardwareBuffer` | 取决于消费者 | `saveLayer()`、`RenderEffect`、`HardwareBufferRenderer` |
| App GPU | `HardwareBuffer` | 独立 `SurfaceControl` layer | EGL / Vulkan 生产后调用 `Transaction#setBuffer()` |

下面这张图把生产和显示分成两段。图中的 present 只存在于最终可见结果，纯离屏任务不会自然获得 display present fence。

```mermaid
flowchart TD
    Classify["确认生产者与输出位置"]
    CpuSurface["CPU → 可见 Surface buffer"]
    CpuBitmap["CPU → Bitmap 中间结果"]
    GpuOffscreen["HWUI / GPU → 离屏目标"]
    DirectBuffer["HardwareBuffer → SurfaceControl transaction"]
    Host["宿主窗口采样中间结果"]
    Pure["缓存 / 编码 / 算法"]
    Layer["最终可见 layer"]
    SF["SurfaceFlinger FrontEnd<br/>transaction readiness + snapshot"]
    HWC["CompositionEngine / Composer HAL<br/>DEVICE 或 CLIENT composition"]
    Driver["Display driver"]
    Present["display present feedback<br/>per-layer release fence"]

    Classify --> CpuSurface --> Layer
    Classify --> CpuBitmap --> Host --> Layer
    Classify --> GpuOffscreen --> Host
    GpuOffscreen --> Pure
    GpuOffscreen --> DirectBuffer --> Layer
    Pure --> NoDisplay["没有 SF / HWC / present<br/>除非稍后进入可见消费者"]
    Layer --> SF --> HWC --> Driver --> Present
```

图里最关键的一条线是“中间结果 → 消费者”。离屏生产完成只说明 buffer 可读，无法说明用户已经看到内容。要把生产耗时、消费等待和显示耗时分别落到对应时间线上。

## 2. CPU 直接写可见 Surface

整窗口关闭硬件加速时，Android 17 的 `ViewRootImpl.drawSoftware()` 会锁住窗口 `Surface`，取得软件 `Canvas`，调用 `mView.draw(canvas)` 绘制 View 树，随后执行 `unlockCanvasAndPost()`。自定义 Surface 绘制也可以由业务线程通过 `SurfaceHolder.lockCanvas()` 完成，线程节奏不必跟随宿主窗口的 `Choreographer`。

这条链路的源码形状如下。代码只保留诊断需要的调用关系，异常处理、坐标变换和脏区维护均已省略。

```text
ViewRootImpl.drawSoftware(...)
  → Surface.lockCanvas(dirty)
    → android_view_Surface.nativeLockCanvas(...)
      → Surface::lock(...)
        → dequeueBuffer(...)
        → GraphicBuffer::lockAsync(...)
  → View.draw(canvas)
  → Surface.unlockCanvasAndPost(canvas)
    → Surface::unlockAndPost()
      → GraphicBuffer::unlockAsync(&fenceFd)
      → queueBuffer(buffer, fenceFd)
```

这段关系说明软件绘制仍受 BufferQueue 生命周期约束。`lockCanvas()` 可能等待可用 slot 或上一轮 release fence，CPU 栅格化只是锁成功之后的一段。使用脏区绘制时，native `Surface` 还可能复制上一块 buffer 中未变更的区域；高分辨率窗口中的 copyback 会消耗可观的内存带宽。

`unlockCanvasAndPost()` 之后，buffer 进入可见 Surface 的消费路径。SurfaceFlinger 等待必要的 acquire fence，选择本轮 layer snapshot，并交给 HWC 规划 DEVICE composition 或 CLIENT composition。存在 CLIENT layer 时，RenderEngine 先生成 client target，再由 `HWComposer::setClientTarget()` 交给 HWC。Android 17 最终通过 `presentAndGetReleaseFences()` 取得显示 present fence 和各 layer 的 release fence。

CPU 生成的 buffer 并不会被强制分配到 HWC overlay。format、dataspace、缩放、旋转、裁剪、alpha 和设备能力共同决定组合方式。软件绘制慢和 CLIENT composition 慢也要分开：前者发生在 App 生产阶段，后者发生在 SurfaceFlinger / RenderEngine 的显示阶段。

## 3. View 的 software layer

`View#setLayerType(LAYER_TYPE_SOFTWARE, paint)` 只改变指定 View 子树的绘制方式。即便窗口开启硬件加速，该子树仍会被软件栅格化到 Bitmap，再作为缓存结果参与宿主窗口的硬件绘制。宿主窗口的 HWUI RenderThread、窗口 BufferQueue 和 SurfaceFlinger layer 都还存在。

这条路径有三个容易混淆的边界。

第一，SurfaceFlinger 看不到独立的“software View layer”。View 子树已经被扁平化到宿主窗口 buffer，SF 侧只能观察宿主 App Window。Perfetto 中最终 `BufferTX - <layerName>`、latch 和 present 也属于宿主窗口。

第二，公开的 `View.buildDrawingCache()` 从 API 28 起已弃用，不能据此把 Android 17 的 software layer 固定描述成某个历史私有函数序列。稳定的公开语义是“软件渲染到 Bitmap”。源码跟读可以查看 `View#setLayerType()`、`buildLayer()` 和 display list 更新分支，但诊断结论应落在 Bitmap 分配、CPU 栅格化、缓存失效与 GPU 采样成本上。

第三，`LAYER_TYPE_HARDWARE`、硬件加速 Canvas 的 `saveLayer()`、`RenderEffect` 和 Compose 离屏合成都属于 GPU 中间目标。它们可能创建纹理或 render target，并不会自动出现 CPU Bitmap 栅格化。相同的模糊或透明效果，在软件 Canvas 和硬件 Canvas 上会落到不同的执行单元。

判断单个 View 的 software layer 时，需要同时看到两部分证据：主线程或相关 CPU 线程上的软件绘制成本，以及宿主 RenderThread 的窗口帧。只看到前者不足以证明整窗口退出 HWUI；只看 `DrawFrame` 又会漏掉前面为 Bitmap 生成像素的时间。

## 4. GPU 与 HardwareBuffer 离屏渲染

离屏渲染可以只服务于本地缓存、缩略图、编码和算法处理，也可以生成稍后要上屏的内容。前一种路径没有 SurfaceFlinger layer；后一种路径要继续追踪宿主窗口采样或独立 layer 提交。

Android 14 / API 34 提供公开的 `HardwareBufferRenderer`。它把 `RenderNode` 场景画入调用方提供的 `HardwareBuffer`，适合生成可供系统合成器、编码器或后续 GPU pass 使用的结果。它与 `HardwareRenderer` 使用同一个进程级 HWUI render thread，因此某个 consumer 长时间不释放资源或某次 GPU 工作过重，可能影响该进程里的其他 HWUI renderer。

`HardwareBufferRenderer.RenderResult#getFence()` 返回的是中间 buffer 的生产完成 fence。消费者在读取 buffer 前需要等待或把 fence 继续向下传递。它与 display present fence 的语义不同：前者保护“何时可以读这块 buffer”，后者表示“一轮 display frame 已进入显示设备的 present 边界”。

使用 `HardwareBufferRenderer` 还要注意两个所有权规则。

- renderer 不会在每次 draw 前自动清空 `HardwareBuffer`；复用 buffer 时应全量覆盖或显式清屏，避免旧像素残留。
- `close()` 释放 renderer 资源，不会替调用方关闭传入的 `HardwareBuffer`；buffer 池、关闭时机和跨模块引用仍由调用方管理。

传统的 `HardwareRenderer` 面向输出 `Surface`，公开于 API 29；EGL / Vulkan 也可以直接把 `AHardwareBuffer` 导入为图像并完成离屏绘制。Perfetto 分析时要先确认 API 与实现：看到 App 自有 GL / Vulkan 线程时，不应把它归到 HWUI common render thread。

## 5. SurfaceControl.setBuffer 直接提交

Android 13 / API 33 起，公开的 `SurfaceControl.Transaction#setBuffer()` 可以把 `HardwareBuffer` 直接设置到 `SurfaceControl`。这里跳过的是该 layer 在 producer 侧的 `dequeueBuffer()` / `queueBuffer()` 循环；SurfaceFlinger transaction、fence readiness、layer snapshot、HWC composition 和 release 生命周期仍然存在。

直接提交的同步关系如下。

```mermaid
sequenceDiagram
    participant Producer as CPU / GPU producer
    participant Tx as SurfaceControl.Transaction
    participant SF as SurfaceFlinger
    participant HWC as CompositionEngine / Composer HAL
    participant DD as Display driver
    participant Pool as Buffer owner

    Producer->>Producer: 写入 HardwareBuffer
    Producer-->>Tx: buffer + production fence
    Tx->>Tx: setBuffer + geometry + visibility
    Tx->>SF: apply()
    SF->>SF: 等待 transaction 与 buffer ready
    alt production fence 与 transaction 条件满足
        SF->>SF: 选择新 buffer 并更新 layer snapshot
    else fence 未 signal 或状态未就绪
        SF->>SF: 沿用旧内容或错过目标帧
    end
    SF->>HWC: validate / presentOrValidate 当前 layer 集合
    opt 需要 CLIENT composition
        SF->>SF: RenderEngine 生成 client target
        SF->>HWC: setClientTarget
    end
    opt 当前轮尚未 present
        SF->>HWC: presentDisplay
    end
    HWC->>DD: 提交 display frame
    DD-->>SF: display present fence
    HWC-->>SF: layer release fence
    SF-->>Pool: release callback
    Pool->>Pool: 等 release fence 后复用 buffer
```

提交时 buffer 仍在写入，就应把有效 `SyncFence` 交给 `setBuffer()`。compositor 会等待它 signal。一个 transaction 同时设置多块 buffer 时，所有 production fence 都满足之后，这组 buffer 才能保持原子一致地显示；其中一块晚到会拖住整组 transaction。

用于 `setBuffer()` 的 `HardwareBuffer` 需要同时支持 `USAGE_COMPOSER_OVERLAY` 和 `USAGE_GPU_SAMPLED_IMAGE`，因为设备可能使用硬件 plane，也可能由 GPU 采样。usage 只表示允许的消费者，无法保证 HWC 一定选择 DEVICE composition。

连续生产必须使用 release callback 或等价的 release fence 管理复用。Java 带 `releaseCallback` 的 overload 会在当前 buffer 可以安全复用时回调；返回的 `SyncFence` 有效时，复用前必须等待。Android 16 / API 36 起，NDK 提供 `ASurfaceTransaction_setBufferWithRelease()`，把当前 `AHardwareBuffer` 的 release 回调与提交绑定。旧的 transaction complete 回调描述的是 transaction 完成状态，不能替代当前 buffer 的可靠回收协议。

## 6. 调度、fence 与 buffer 生命周期

软件和离屏路径没有统一的起跑线。

- 整窗口 `drawSoftware()` 通常仍由 ViewRoot 的 traversal 与 `Choreographer#doFrame()` 驱动，主要工作落在主线程。
- `SurfaceHolder.lockCanvas()` 可以运行在业务线程的循环中，生产节奏由应用决定。
- `HardwareBufferRenderer` 由调用线程发起 request，绘制工作进入 common HWUI render thread 和 GPU。
- EGL / Vulkan 离屏任务可以完全脱离 `vsync-app`，直到某个可见消费者在自己的帧里使用结果。

一块会上屏的离屏 buffer，至少要分清三类 fence。

| fence | 保护的边界 | 等待方 | 常见错误 |
|---|---|---|---|
| production / acquire fence | producer 已完成写入，consumer 可以读取 | 宿主 GPU、SurfaceFlinger 或其他消费者 | 把它当作已显示证明 |
| display present fence | 这一轮 display frame 到达显示 present 边界 | SurfaceFlinger 的显示时间线 | 当成某块 buffer 独享的 fence |
| layer release fence | consumer 不再读取该 buffer，可以回池复用 | producer / buffer pool | callback 一到就立即写，未等待有效 fence |

纯离屏任务通常只有生产完成与消费者 release 边界。没有可见 layer，也就没有 SF latch、HWC validate/present 和 display present fence。Perfetto 中找不到 SF 对象时，应先检查任务是否设计上就不需要上屏。

进入 Android kernel 后，跨设备和跨进程共享的图形 buffer 通常由 dma-buf 表示，同步通过 dma-fence，并可借助 sync_file 暴露为文件描述符。`android17-6.18-2026-06_r6` 锚点下，应用层的 `SyncFence`、native fence fd 与内核 dma-fence 是同一条所有权链上的不同接口层。trace 中看到 fence wait 时，要继续确认等待的是 GPU 写入、HWC 释放，还是 buffer pool 自身不足。

## 7. Perfetto 证据链

分析顺序应从 producer 开始，再追 consumer，继而检查可见 layer。SurfaceFlinger 平静只能说明结果尚未进入它的视野，无法排除前面的生产延迟。

### 第一步：确认最终结果是否可见

先在 SurfaceFlinger layer、WindowManager 窗口和目标 display 中寻找对应对象。纯 Bitmap 缓存、编码输入或算法 buffer 不会自然生成 SF layer。通过宿主窗口采样的中间结果只对应宿主 layer；通过 `setBuffer()` 提交的结果才对应目标 `SurfaceControl` layer。

### 第二步：确认像素生产者

| trace 现象 | 更可能的路径 | 下一步 |
|---|---|---|
| 没有 HWUI `DrawFrame`，主线程出现软件 View 绘制 | 整窗口 software rendering | 查 `lockCanvas` 等待、View 树 CPU 栅格化、post 时间 |
| 业务线程周期性 lock/post 独立 Surface | `SurfaceHolder` 软件生产者 | 查线程节奏、BufferQueue slot 与 release fence |
| 有宿主 `DrawFrame`，前面伴随 Bitmap 分配和 CPU raster | 单个 View software layer 或 Bitmap 缓存 | 查缓存失效、尺寸、上传和 GC |
| RenderThread / GPU 出现离屏 pass，没有对应 SF layer | GPU 纯离屏任务 | 找编码器、ImageReader、缓存或算法消费者 |
| 出现 `HardwareBufferRenderer` request 和 `setBuffer` transaction | `HardwareBuffer` 直接提交 | 对齐生产 fence、transaction、latch 与 release callback |

slice 名会受设备厂商、图形后端和 trace 配置影响。没有某个固定字符串时，可以用线程、调用栈、fence、buffer id 和 layer id 建立关系，不要把一条 slice 名当作类型定义。

### 第三步：把等待拆开

`lockCanvas()` 变长时，先看线程状态。如果线程睡眠在 `dequeueBuffer`、futex 或 fence wait，问题位于 buffer 可用性；锁成功后长时间 Running，才更像 CPU 绘制或内存带宽压力。

`HardwareBufferRenderer` 的 callback 变晚时，要分辨 common RenderThread 排队、GPU 执行和完成 fence signal。`setBuffer()` 已 apply 但 layer 没更新时，再查 transaction readiness、production fence、期望显示时间、目标 layer 是否可见，以及是否沿用旧 buffer。

最终显示阶段关注以下证据：目标 layer 的 transaction / buffer 更新、SurfaceFlinger latch、composition type、RenderEngine CLIENT composition、HWC present、display present fence 和 layer release fence。生产快而 present 晚，瓶颈位于显示后半段；生产本身已越过目标 deadline，SF 只能显示旧内容或错过当前周期。

### 第四步：量化节拍

不要只量一帧。连续帧至少记录：请求时间、拿到可写 buffer 的时间、生产完成时间、提交时间、latch 时间、present 时间、release 时间。用 buffer id 或 transaction id 关联同一帧，才能区分以下三种问题：生产变慢、消费间隔变长、buffer 池耗尽后反压 producer。

## 8. 性能成本与内存压力

Software / 离屏问题经常由内存流量主导。RGBA_8888 的理论字节量可用下面的式子估算：

`width × height × 4 × bufferCount`

一张 1440 × 3200 的 RGBA_8888 buffer 约为 17.6 MiB。三缓冲只计算像素存储就超过 52 MiB；再叠加软件脏区 copyback、CPU 写入、纹理上传、GPU 采样和 client composition，单帧可能多次穿过内存系统。

Perfetto 中可以补看这些轨道：

- CPU 调度、频率和 Running 时间，判断软件栅格化是否受算力或抢占影响；
- ART GC、native heap、Bitmap 与 graphics memory，判断缓存反复分配；
- GPU queue、GPU frequency 和 render stage，判断离屏 pass 是否挤占窗口帧；
- dma-buf 分配、page fault、direct reclaim、`kswapd`、zram 和 PSI memory，判断内存回收是否进入关键路径；
- HWC composition type 与 RenderEngine，判断中间结果的 format、缩放或透明度是否触发额外 CLIENT composition。

优化时优先削减不必要的中间结果面积和更新频率。software layer 的 bounds、`saveLayer()` 的范围、模糊半径、`HardwareBuffer` 尺寸和 buffer 池深度都会直接放大成本。局部效果却分配全屏离屏目标，是这类路径中最常见的浪费之一。

## 9. Android 12—17 版本演进

版本演进需要同时看稳定主干和新增公开能力。Android 12 以前的 `lockCanvas()`、View software layer、`HardwareRenderer`、EGL 与 BufferQueue 仍有历史意义，但现代诊断从 Android 12 起更贴近当前设备和 trace 结构。

### Android 12 / API 31

CPU 直写 `Surface`、单 View software layer 和 HWUI 离屏 layer 已经是成熟路径。Android 12 引入公开 `RenderEffect`，模糊、颜色和 shader 效果更容易触发 GPU 中间渲染；同时 BLAST 与 FrameTimeline 成为现代窗口显示分析的重要背景。此时还没有公开 `HardwareBufferRenderer`，离屏硬件生产通常使用 `HardwareRenderer` + `Surface`、EGL / Vulkan 或平台私有接口。

### Android 13 / API 33

`SurfaceControl.Transaction#setBuffer()`、平台 `SyncFence` 以及相关 release callback 成为公开 API。应用可以把符合 usage 要求的 `HardwareBuffer` 直接设置到 `SurfaceControl`，并显式传递生产 fence 与回收 fence。直接 buffer transaction 从这一版起具备清晰的公开 Java API 边界。

### Android 14 / API 34

`HardwareBufferRenderer` 成为公开 API，提供 `RenderNode → HardwareBuffer` 的现代离屏 HWUI 路径。它复用 common render thread，返回生产完成 fence，并明确把 buffer 清理和关闭责任留给调用方。离屏生产与最终显示由此可以通过公开 API 分层实现。

### Android 15 / API 35

`SurfaceControl.Transaction#setFrameTimeline()`、desired present time 和更完整的 transaction 完成反馈，让直接提交的 buffer 更容易表达目标显示周期并建立观测边界。这些 API 没有改变 buffer 的生产方式，作用集中在 transaction 调度与完成反馈。

### Android 16 / API 36

NDK 增加 `ASurfaceTransaction_setBufferWithRelease()`。Native producer 可以在提交 `AHardwareBuffer` 时绑定当前 buffer 的 release callback，避免用 transaction 完成回调推测 buffer 是否已安全释放。Java 侧已有对应能力，这一版补齐了 NDK 连续 buffer 生产的回收语义。

### Android 17 / API 37

本文讨论的四条主路径保持稳定：`drawSoftware()` / `lockCanvas()`、View software layer、`HardwareBufferRenderer` 离屏生产、`SurfaceControl.Transaction#setBuffer()` 直接提交。源码锚点统一到 `android-17.0.0_r1` 后，显示后半段应按当前 SurfaceFlinger FrontEnd layer snapshot、CompositionEngine、AIDL Composer HAL 和 `presentAndGetReleaseFences()` 理解；不能把早期 HWC2 教程中的函数序列直接当作 Android 17 的完整实现。

kernel 锚点统一到 `android17-6.18-2026-06_r6` 后，dma-buf、dma-fence 与 sync_file 仍是 buffer 共享和同步的核心基础设施。上层 API 名称在演进，buffer 所有权、生产完成、显示消费和安全复用这四个问题一直存在。

## 10. Android 17 源码入口

下面的入口足以覆盖 CPU 软件绘制、HWUI 离屏生产、直接 buffer transaction 和最终显示。

- [`ViewRootImpl.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/core/java/android/view/ViewRootImpl.java)：查看 `drawSoftware()` 如何锁窗口 Surface、绘制根 View 并 post buffer。
- [`Surface.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/core/java/android/view/Surface.java) 与 [`android_view_Surface.cpp`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/core/jni/android_view_Surface.cpp)：查看 Java Canvas 锁定与 native `Surface` 的桥接。
- [`Surface.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/libs/gui/Surface.cpp) 与 [`GraphicBuffer.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/libs/ui/GraphicBuffer.cpp)：查看 `dequeueBuffer()`、`lockAsync()`、`unlockAsync()` 和 `queueBuffer()`。
- [`View.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/core/java/android/view/View.java) 与 [View layer 官方说明](https://developer.android.com/develop/ui/views/graphics/hardware-accel)：核对 `LAYER_TYPE_SOFTWARE` 的公开语义与实现分支。
- [`HardwareBufferRenderer.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/graphics/java/android/graphics/HardwareBufferRenderer.java) 与 [API Reference](https://developer.android.com/reference/android/graphics/HardwareBufferRenderer)：核对 common render thread、生产 fence、清屏和资源所有权。
- [`SurfaceControl.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/core/java/android/view/SurfaceControl.java) 与 [`SurfaceControl.Transaction` API Reference](https://developer.android.com/reference/android/view/SurfaceControl.Transaction)：核对 `setBuffer()`、usage、production fence 和 release callback。
- [NDK Native Activity / SurfaceControl Reference](https://developer.android.com/ndk/reference/group/native-activity)：核对 API 36 的 `ASurfaceTransaction_setBufferWithRelease()`。
- [`SurfaceFlinger.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/services/surfaceflinger/SurfaceFlinger.cpp)、[`HWComposer.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/services/surfaceflinger/DisplayHardware/HWComposer.cpp) 与 [`HWC2.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/services/surfaceflinger/DisplayHardware/HWC2.cpp)：核对最终 layer snapshot、composition 和 present / release fence。
- Android17 kernel [`dma-buf.rst`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/Documentation/driver-api/dma-buf.rst)、[`sync_file.rst`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/Documentation/driver-api/sync_file.rst) 与 [`sync_file.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/drivers/dma-buf/sync_file.c)：核对共享 buffer、dma-fence 和 fence fd 的基础语义。

## 11. 类型边界与常见误判

### 与标准 HWUI 窗口的边界

标准 HWUI 窗口由 UI Thread 更新 RenderNode / display list，RenderThread 和 GPU 直接生成当前窗口 buffer。整窗口 software rendering 把像素生产移到 CPU；View software layer 只把某个子树移到 CPU，最终窗口仍由 HWUI 输出；GPU 离屏则在最终窗口之前增加中间 render target。

### 与 Native Graphics 的边界

App 自有 EGL / Vulkan 线程如果直接面向可见 `Surface` 的 swapchain 持续出图，应归入 Native Graphics。相同线程先写 `HardwareBuffer`，结果用于缓存、编码或稍后 `setBuffer()`，本篇的离屏生产与消费模型更合适。分类依据是 buffer 的去向，不是开发语言。

### 常见误判

| 误判 | 正确检查方式 |
|---|---|
| 没有 `DrawFrame`，trace 一定漏采 | 查整窗口 `drawSoftware()`、`lockCanvas()` 和自定义 Surface 线程 |
| `lockCanvas()` 很长，CPU 绘制很慢 | 先拆开 slot / release fence 等待与锁成功后的 CPU Running 时间 |
| `LAYER_TYPE_SOFTWARE` 会让整个窗口退出 HWUI | 查宿主 RenderThread 和 App Window buffer；它只影响 View 子树 |
| 离屏渲染都由 CPU 完成 | 查 HWUI / Skia offscreen pass、EGL / Vulkan 和 `HardwareBufferRenderer` |
| `RenderResult#getFence()` 表示已经上屏 | 它只表示中间 buffer 的生产完成；显示还要经过消费者、SF 和 HWC |
| `setBuffer()` 绕过 SurfaceFlinger | 它只绕过 producer 侧 BufferQueue 循环，SF transaction 与 composition 仍在 |
| transaction complete 后 buffer 一定可以复用 | 使用专门的 release callback，并等待回调携带的有效 release fence |
| HWC overlay usage 能保证 DEVICE composition | usage 只允许该消费方式，最终选择还受整组 layer 和设备能力影响 |

## 总结

Software / 离屏类型要用两个维度判断：生产者是谁，结果先落在哪里。CPU `lockCanvas()` 可以直接生成可见 Surface buffer；`LAYER_TYPE_SOFTWARE` 只把 View 子树栅格化成 Bitmap；`HardwareBufferRenderer` 与 EGL / Vulkan 可以在 GPU 上生成离屏结果；`SurfaceControl.Transaction#setBuffer()` 再把 `HardwareBuffer` 接入独立 layer 的显示链路。

Perfetto 分析时按 producer、intermediate buffer、consumer、visible layer 的顺序取证，并分别对齐 production fence、display present fence 和 layer release fence。这样才能判断慢点位于像素生成、buffer 等待、消费衔接，还是 SurfaceFlinger / HWC 的最终显示阶段。

GENERATED FILE - DO NOT EDIT.
Source: docs/rendering_pipelines/S08_native_graphics_type.md
Source SHA-256: 2abcf50db6a318723ff2427f3e1299f4ab44c8f82fd7e64f63e1eaa372c280e2

# Android Perfetto 系列 - App 出图类型 - Native Graphics 类型

Native Graphics 的识别标准不在 C++、OpenGL ES 或 Vulkan 这些标签本身，而在画面生产权：关键内容由应用自己的 render loop 获取 buffer、组织 GPU 工作并提交到可见 `Surface`。普通 ViewRoot 和 HWUI RenderThread 可能只负责窗口外壳，也可能完全不参与主体画面。

这篇文章以 Android 17 / API 37、`android-17.0.0_r1` 为平台源码锚点，kernel 侧以 `android17-6.18-2026-06_r6` 为锚点。EGL、Vulkan WSI、ANGLE 和 Swappy 的版本边界分别说明，避免把图形库能力当作所有 Android 17 设备的固定行为。

<!--more-->

## 阅读导航

### 本文目录

- 1. Native Graphics 的系统位置
- 2. EGL / OpenGL ES 一帧怎样提交
- 3. Vulkan swapchain 一帧怎样提交
- 4. render loop 与 frame pacing
- 5. ANGLE：GLES API 下的 Vulkan backend
- 6. BufferQueue、SurfaceFlinger 与 HWC 收尾
- 7. Perfetto 证据链
- 8. 常见瓶颈与优化方向
- 9. Android 12—17 版本演进
- 10. Android 17 源码入口
- 11. 类型边界与常见误判
- 总结

### 系列文章目录

1. [Android Perfetto 系列 - App 出图类型 - 总览与识别方法](S01_rendering_types_overview.md)
2. [Android Perfetto 系列 - App 出图类型 - AOSP 标准类型](S02_aosp_standard_type.md)
3. [Android Perfetto 系列 - App 出图类型 - SurfaceView 类型](S03_surfaceview_type.md)
4. [Android Perfetto 系列 - App 出图类型 - TextureView 类型](S04_textureview_type.md)
5. [Android Perfetto 系列 - App 出图类型 - 混合出图类型](S05_mixed_rendering_type.md)
6. [Android Perfetto 系列 - App 出图类型 - 多窗口类型](S06_multi_window_type.md)
7. [Android Perfetto 系列 - App 出图类型 - Software / 离屏类型](S07_software_offscreen_type.md)
8. [Android Perfetto 系列 - App 出图类型 - Native Graphics 类型](S08_native_graphics_type.md)
9. [Android Perfetto 系列 - App 出图类型 - WebView 类型](S09_webview_type.md)
10. [Android Perfetto 系列 - App 出图类型 - Flutter 类型](S10_flutter_type.md)
11. [Android Perfetto 系列 - App 出图类型 - Camera 类型](S11_camera_type.md)
12. [Android Perfetto 系列 - App 出图类型 - Video Overlay / HWC 类型](S12_video_overlay_hwc_type.md)
13. [Android Perfetto 系列 - App 出图类型 - Game 类型](S13_game_type.md)
14. [Android Perfetto 系列 - App 出图类型 - React Native 类型](S14_react_native_type.md)

## 1. Native Graphics 的系统位置

Native Graphics 通常由 `SurfaceView`、`NativeActivity`、`GameActivity` 或引擎自己的窗口封装提供 `Surface`。Java `Surface` 通过 `ANativeWindow_fromSurface()` 转换为带引用计数的 `ANativeWindow`；EGL window surface 和 Vulkan Android surface 都以它为平台连接点。AOSP 内部的 `android::Surface` 实现 `ANativeWindow` 接口，并连接到 BufferQueue producer。

应用掌握的是 producer 前半段，系统仍掌握 consumer 后半段。

```mermaid
flowchart TD
    Host["Activity / GameActivity / NativeActivity"]
    Surface["Surface → ANativeWindow"]
    Clock["AChoreographer / engine scheduler<br/>frame pacing target"]
    Loop["App-owned render loop<br/>logic / render / RHI threads"]
    GLES["OpenGL ES commands"]
    EGL["EGL window surface<br/>eglSwapBuffers"]
    Vulkan["Vulkan WSI<br/>acquire → submit → present"]
    Angle["optional ANGLE backend<br/>GLES → Vulkan"]
    Driver["vendor GLES / Vulkan driver"]
    GPU["GPU queue<br/>producer completion fence"]
    BQ["BufferQueue<br/>dequeue / queue + fence"]
    SF["SurfaceFlinger<br/>transaction readiness + latch"]
    HWC["CompositionEngine / HWC<br/>DEVICE 或 CLIENT"]
    Display["Composer HAL / display driver"]
    Present["display present feedback<br/>per-layer release fence"]
    HostUI["可选宿主 UI layer<br/>ViewRoot + HWUI"]

    Host --> Surface
    Clock --> Loop
    Surface --> Loop
    Loop --> GLES --> EGL --> Driver
    GLES -. selected backend .-> Angle --> Driver
    Loop --> Vulkan --> Driver
    Driver --> GPU --> BQ
    Host --> HostUI --> SF
    BQ --> SF --> HWC --> Display --> Present
```

图中的宿主 UI 与 native surface 经常是两个 layer。比如游戏主体画在 `SurfaceView` child layer，登录弹窗或系统栏由另一个窗口 / layer 提供。引擎内 HUD 若直接画入同一张 swapchain image，SurfaceFlinger 只看到一层，不能因为画面上有按钮就推断系统多了一层。

Native render loop 也不等于纯 native 进程。Java/Kotlin 可以创建窗口和处理生命周期，C++ 只接管渲染；Flutter、WebView 或视频组件内部也可能有 native GPU 线程。归类时看主体画面的 producer 和最终 Surface，不看调用语言。

## 2. EGL / OpenGL ES 一帧怎样提交

EGL window surface 把 OpenGL ES 与 `ANativeWindow` 接在一起。应用在线程上绑定 EGL 上下文和 surface，发出 GLES draw call，再调用 `eglSwapBuffers()` 交付当前 back buffer。

下面的调用关系用于定位 trace，不代表每个 vendor EGL 都在同一个函数里完成所有动作。

```text
render thread
  → GLES draw calls
  → eglSwapBuffers(display, surface)
    → flush / submit pending GPU work
    → ANativeWindow queueBuffer(currentBuffer, productionFence)
    → acquire or prepare another buffer as implementation requires
  → next frame
```

`eglSwapBuffers()` 的时长混合了多种成本：driver flush、GPU queue 管理、等待可用 BufferQueue slot、等待 release fence、swap interval、presentation time 和 frame pacing。函数很长只能说明调用线程没有立即返回，无法直接证明 GPU shader 很慢。

buffer 随 `queueBuffer()` 进入 consumer 后，producer completion fence 在 SurfaceFlinger 侧作为 acquire fence 使用：fence signal 前，consumer 不能读取尚未写完的像素。显示完成后，per-layer release fence 回到 producer，决定旧 buffer 何时能够再次被写入。

EGL swap 的返回也不代表画面已经显示。它通常只表示当前 buffer 已交给平台队列，并满足 EGL 实现定义的同步要求。用户可见时间还要继续经过 SF latch、HWC / RenderEngine composition 和 display present。

## 3. Vulkan swapchain 一帧怎样提交

Vulkan 把 image 获取、GPU 提交和 present 拆成显式步骤。Android Vulkan WSI 通过 `VK_KHR_android_surface` 把 `VkSurfaceKHR` 连接到 `ANativeWindow`，swapchain image 与 BufferQueue buffer 建立对应关系。

```mermaid
sequenceDiagram
    participant App as Vulkan / RHI thread
    participant WSI as Android Vulkan WSI
    participant BQ as ANativeWindow / BufferQueue
    participant GPU as GPU queue
    participant SF as SurfaceFlinger
    participant HWC as Composer HAL / RenderEngine
    participant DD as Display driver

    App->>WSI: vkAcquireNextImageKHR()
    WSI->>BQ: dequeueBuffer()
    BQ-->>WSI: image + dequeue fence
    WSI->>GPU: import acquire dependency
    App->>App: record command buffers
    App->>GPU: vkQueueSubmit(wait imageAvailable,<br/>signal renderFinished)
    App->>WSI: vkQueuePresentKHR(wait renderFinished)
    WSI->>BQ: queueBuffer(image, production fence)
    BQ->>SF: buffer update + acquire fence
    SF->>SF: 更新 snapshot 并选择 ready buffer
    SF->>HWC: validate / presentOrValidate layer 集合
    opt CLIENT composition required
        SF->>SF: RenderEngine 生成 client target
        SF->>HWC: setClientTarget
    end
    opt 当前轮尚未 present
        SF->>HWC: presentDisplay
    end
    HWC->>DD: 提交 display frame
    DD-->>SF: display present fence
    HWC-->>SF: layer release fences
    SF-->>BQ: release fence controls future acquire
```

AOSP Android 17 的 `vulkan/libvulkan/swapchain.cpp` 展示了平台内部桥接：acquire 路径从 native window dequeue buffer，并通过驱动的 Android WSI 接口导入 fence；present 路径取得 producer 完成 fence，再把 image queue 回 native window。这里的 producer fence 仍然不是 display present fence。

`vkAcquireNextImageKHR()` 可能阻塞，也可能立即返回；`vkQueuePresentKHR()` 也可能因 driver 和 presentation engine 状态呈现不同阻塞行为。它们只能管理 swapchain，不能充当业务线程之间的通用同步器。GPU—GPU 依赖使用 semaphore，GPU—CPU 完成通知使用 fence，resource hazard 使用 pipeline barrier 或 event。

swapchain 的 image count、format、color space、extent、preTransform、usage 和 present mode 都应从 surface capabilities 查询。不能把桌面平台常见的 IMMEDIATE、MAILBOX 或 FIFO_RELAXED 当作 Android 设备必有能力。旋转时忽略 `currentTransform` / pre-rotation 还可能增加 compositor 旋转成本，并降低 overlay 机会。

## 4. render loop 与 frame pacing

Native render loop 的起点可能来自 `AChoreographer`、引擎 scheduler、音频时钟、网络 tick、XR 运行时或上一帧 backpressure。`vsync-app` 可以是 pacing 参考，也可以只驱动宿主 UI。判断一帧从哪里开始，要以引擎 marker、输入采样和 acquire / submit 序列为证据。

“能多快就多快地 present”会把 BufferQueue 塞满。队列满后，render thread 被迫在 swap 或 acquire 中等待显示消费，形成 queue-stuffing：表面帧率可能接近目标值，输入却在较早的帧中采样，额外排队直接增加触控到显示延迟。

Android Frame Pacing library（Swappy）是 AGDK 库，不属于 `android-17.0.0_r1` 平台 API。OpenGL ES 接入点是 `SwappyGL_swap()`，它包装 `eglSwapBuffers()`；Vulkan 接入点是 `SwappyVk_queuePresent()`，它代为调用 `vkQueuePresentKHR()`，并可能向 present queue 插入同步命令。分析前要先确认应用打包的 Swappy 版本和运行时是否成功启用。

Swappy 综合 Choreographer、presentation timestamp 和 sync fence，控制 swap interval、目标 present 时间与 pipeline mode。它的主动等待可能是在避免 queue-stuffing，不应直接标为卡顿。判断这段等待是否合理，要比较目标帧率、相邻 present 间隔、输入延迟和队列深度。

Vulkan 应用也可以自己实现 pacing。较早设备可查询 `VK_GOOGLE_display_timing`，设置 desired present time 并读取过去的 presentation timing；Android 17 / API 37 起新增 `VK_EXT_present_timing` 平台支持，提供标准化且更细的 present 阶段反馈。extension 必须在运行时枚举，Android 17 版本号不等于所有物理设备、驱动与 swapchain 组合都支持应用想用的全部扩展能力。

帧率选择与帧 pacing 是两个问题。`ANativeWindow_setFrameRate()` / Java `Surface#setFrameRate()` 向系统声明内容帧率和兼容性，系统再结合其他 layer、显示模式和切换策略选择 refresh rate；pacing 决定应用把每一帧放到哪个显示周期。只改 refresh rate 而不修正提交节拍，仍会出现短帧、长帧交替。

## 5. ANGLE：GLES API 下的 Vulkan backend

ANGLE 可以把应用的 OpenGL ES / EGL 调用翻译到 Vulkan 等 backend。此时应用可见边界仍是 GLES draw call 和 `eglSwapBuffers()`，底层却可能出现 Vulkan command buffer、queue submit 和 Vulkan driver 工作。

诊断时把成本分成三段：应用 GLES 调用，ANGLE 状态跟踪与命令翻译，Vulkan driver / GPU 执行。大量细碎 GLES 状态切换、shader 编译或 pipeline 缓存未命中可能在 ANGLE 层放大；另一台设备也可能因为 Vulkan driver 更稳定而获得更好的兼容性和性能。

ANGLE 的选择受系统版本、设备配置、开发者选项、应用 manifest、系统 graphics driver 包和厂商策略共同影响。Android 15 的开发者选项可以用于测试 ANGLE，不代表所有 Android 15 设备默认使用；Android 17 的请求信号也要结合实际 driver selection 验证。Perfetto、logcat、Graphics Driver Inspector 信息或 EGL vendor / renderer 字符串应共同确认 backend。

## 6. BufferQueue、SurfaceFlinger 与 HWC 收尾

GLES 和 Vulkan 的提交最终都变成 BufferQueue producer 的 buffer update。SurfaceFlinger 关心目标 layer、frame number、buffer、dataspace、crop、transform、damage、期望显示时间和 acquire fence；它不需要知道上游使用哪种 shader 语言。

Android 17 的显示后半段可以按以下边界理解：

1. SurfaceFlinger FrontEnd 处理 transaction，生成本轮 `RequestedLayerState` / `LayerSnapshot`。
2. 满足 transaction 与 fence readiness 的 buffer 才能进入候选 snapshot；晚到时可能沿用旧内容或错过目标周期。
3. CompositionEngine 为 display 准备 layer stack，并与 HWC 协商 composition type。
4. 可以直接交给硬件 plane 的 layer 使用 DEVICE composition；需要 GPU 合成的 layer 由 RenderEngine 生成 client target，再通过 `setClientTarget()` 交给 HWC。
5. HWC validate / present 成功后，`presentAndGetReleaseFences()` 收集 display present fence 与 per-layer release fence。`presentOrValidate` 的 PresentSucceeded 快路径已经完成 present，不能再写成随后必定执行第二次 present。

Native Graphics 不保证 DEVICE composition。透明混合、缩放、旋转、HDR / SDR 混合、受保护内容、显示 LUT、其他系统 layer 和 HWC plane 资源都会改变策略。GPU 已经渲染一次的画面若又进入 CLIENT composition，会多一次全屏采样和写回，需要结合 GPU 与内存带宽判断代价。

kernel 锚点 `android17-6.18-2026-06_r6` 下，GraphicBuffer / swapchain image 的跨模块共享落到 dma-buf，GPU、SurfaceFlinger 和 HWC 的异步完成关系通过 dma-fence / sync_file 传递。vendor GPU driver 的 job scheduler、频率、抢占和内存管理决定 GPU 工作何时完成；Android common kernel 锚点并不抹平不同 GPU 驱动的 tracepoint 与调度差异。

## 7. Perfetto 证据链

Native Graphics 应从应用 render loop 向显示端推进。先看普通 HWUI RenderThread，往往只能看到宿主壳或什么都看不到。

### 第一步：锁定 Surface 与 producer 线程

从窗口和 SurfaceFlinger layer 树确认主体画面对应哪个 Surface。再通过线程名、引擎 marker、`eglSwapBuffers()`、`vkAcquireNextImageKHR()`、`vkQueueSubmit()` 和 `vkQueuePresentKHR()` 找到 producer tid。线程名只能提供线索，调用栈与提交事件更可靠。

### 第二步：建立逐帧时间线

每帧至少标出以下节点：输入采样、logic start/end、render preparation、acquire、CPU submit、GPU start/end、swap / queuePresent、BufferQueue queue、SF latch、HWC present、display present、buffer release。引擎 frame id、Vulkan present id、buffer id、frame number 和 FrameTimeline token 能用多少就用多少，避免只按时间邻近猜测。

### 第三步：按 API 拆等待

| 现象 | 可能原因 | 验证证据 |
|---|---|---|
| `eglSwapBuffers()` 长 | driver flush、GPU fence、free slot、release fence、swap interval、Swappy wait | 线程状态、GPU queue、BufferQueue depth、Swappy marker |
| `vkAcquireNextImageKHR()` 长 | 没有可用 image、FIFO 节拍、consumer release 晚、surface resize | image count、present mode、release fence、`OUT_OF_DATE` / `SUBOPTIMAL` |
| `vkQueueSubmit()` 调用晚 | logic / command recording 晚、CPU 抢占、RHI 队列阻塞 | 上游 thread slice、Runnable latency、worker dependency |
| submit 早但 GPU 完成晚 | GPU 负载、shader / pipeline、带宽、driver queue、thermal throttling | GPU stage、frequency、job queue、counter、fence signal |
| buffer 已 queue 但 SF 没换新 | acquire fence 未 ready、目标 present 未到、layer 不可见、transaction 条件未满足 | layer trace、fence、FrameTimeline、transaction 状态 |
| SF latch 正常但 present 晚 | CLIENT composition、HWC validate、display contention | RenderEngine、composition type、HWC 与 present fence |

### 第四步：识别 queue-stuffing

典型信号是 pending buffer 长期维持在高水位，producer 仍持续尽快提交，随后周期性卡在 swap / acquire；输入到 present 延迟增加，帧间隔却可能没有明显恶化。修复方向是显式 pacing、降低 in-flight frame 数、推迟输入采样或调整 pipeline mode，不能只缩短 swap 调用本身。

### 第五步：正确使用 FrameTimeline

普通 App Window 常有完整的 expected / actual timeline。独立 native Surface 是否带标准 App FrameTimeline token，取决于 producer 是否传递 frame timeline / desired present 信息以及 trace 配置。缺少 expected slice 不代表没有显示；此时用 buffer frame number、layer latch、HWC present 和 display fence 补齐。不同 layer 的 token 也不能混成一条窗口帧。

## 8. 常见瓶颈与优化方向

CPU 侧常见问题包括逻辑与渲染串行、command buffer 录制不均、JNI 往返、频繁内存分配、shader / pipeline 同步编译、driver ioctl 阻塞和线程优先级不当。Vulkan 多线程录制只有在任务拆分、command pool 和 descriptor 管理合理时才有收益；线程数量超过可用大核会增加调度与缓存争用。

GPU 侧需要分辨算术、纹理、带宽、tile memory、overdraw、同步 bubble 和频率限制。分辨率缩放能缓解 fragment 与带宽压力，对 CPU draw-call 瓶颈帮助有限；减少 draw call 能缓解 CPU / driver 开销，对全屏重 shader 未必有效。使用 GPU counter 或 vendor profiler 确认瓶颈，再选择策略。

swapchain 配置也会改变延迟。image 太少容易让 acquire 频繁等待，太多又允许更多 in-flight frame，增加输入延迟和显存占用。buffer age、damage region、pre-rotation、颜色空间和 protected usage 都会影响后续合成。最佳配置要按设备能力、目标帧率和 latency 目标测试。

移动设备的持续性能受温度和功耗约束。短时间跑满 GPU 得到的峰值不能代表十分钟后的稳定帧率。ADPF Performance Hint Session、thermal API，以及 Android 16 的 CPU / GPU headroom 可以帮助 workload 自适应；提示系统时应报告真实周期和线程集合，不能把 hint 当作固定锁频接口。

## 9. Android 12—17 版本演进

Native Graphics 的核心桥接在 Android 12 前已经形成：`ANativeWindow`、EGL window surface、Vulkan Android WSI、BufferQueue 与 SurfaceFlinger。现代版本演进更集中在刷新率、frame pacing、HWC 接口、native 兼容性和时间反馈。

### Android 12 / API 31

Android 12 改进 `Surface#setFrameRate()` 的刷新率切换策略，系统可以在显示不支持 seamless transition 时按应用声明选择非无缝切换。BLAST 与 FrameTimeline 构成现代窗口显示诊断基线，能更清楚地区分应用提交晚和 SurfaceFlinger / display 晚。Performance Hint Manager 同期公开，为周期性 native workload 提供 target / actual duration 提示，但它不替代 frame pacing。

### Android 13 / API 33

HWC HAL 从这一版起以 AIDL 定义，HIDL Composer 2.1—2.4 进入弃用路径。SurfaceFlinger 增加 `AutoSingleLayer` 配置，可在只有单 layer 简单 buffer update 时采用 unsignaled buffer latching；涉及 geometry 或 sync transaction 的跨 layer 场景不适用，不能把它解释成任意 native layer 的低延迟通道。Android 13 QPR 还加入游戏 FPS throttling intervention，平台可能在无需游戏改码的情况下限制帧率，因此 trace 中的目标帧率要结合 Game Mode / intervention 配置。

### Android 14 / API 34

EGL / Vulkan 到 BufferQueue 的主路径没有结构性更换。此阶段更值得关注应用是否正确使用 Swappy、ADPF 和 Vulkan Profiles，而不是寻找一个“Android 14 专属 swap 流程”。API 34 新增的 `HardwareBufferRenderer` 服务于 `RenderNode → HardwareBuffer` 离屏生产，不会替换持续面向可见 swapchain 的 EGL / Vulkan producer。

### Android 15 / API 35

Android 15 引入 Adaptive Refresh Rate（ARR）的平台基础，并提供 ANGLE 开发者选项用于测试 GLES 应用的 Vulkan backend。Vulkan Profiles for Android 从 `VPA15_minimums` 建立年度 profile 线，应用仍要运行时查询 API 版本和 extension。AOSP 开始支持 16 KB page size 设备，包含引擎、graphics plugin 和 vendor-independent native library 在内的所有 `.so` 都需要正确的 ELF 与 APK 对齐；这属于 native 可运行性边界，不会改变 swapchain 的 buffer 语义。

### Android 16 / API 36

Android 16 公开 ARR capability / suggested frame rate 相关 API，并在 ADPF 增加 CPU / GPU headroom 观测能力。面向 Android 16 的 GPU syscall filtering 不改变受支持的 OpenGL ES / Vulkan API，但自带非标准 GPU ioctl、注入层或陈旧调试工具需要单独验证。Native Graphics 的诊断主线仍是 acquire、submit、GPU completion、queue、latch 和 present。

### Android 17 / API 37

Android 17 增加 `VK_EXT_present_timing` 平台支持，为自研 Vulkan pacing 提供标准化的 present stage 时间反馈；较老的 `VK_GOOGLE_display_timing` 仍覆盖更多设备。Android 17 同时提供 WebGPU 平台 API，体现 Android 向 Vulkan 作为主要低层 GPU API 的迁移，但已有 EGL / GLES、ANGLE 和 Vulkan 应用不会因此自动切换 backend。

源码分析统一到 `android-17.0.0_r1` 后，Android WSI 要看当前 `swapchain.cpp`，显示端要看 FrontEnd snapshot、CompositionEngine 与 AIDL Composer 路径。kernel 统一到 `android17-6.18-2026-06_r6` 后，再用具体设备的 GPU / display driver tracepoint 补足 dma-buf、dma-fence、job scheduler 和频率信息。

## 10. Android 17 源码入口

- [`native_window.h`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/libs/nativewindow/include/android/native_window.h) 与 [`native_window_jni.h`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/include/android/native_window_jni.h)：查看 `ANativeWindow` NDK 接口、Java Surface 转换与引用计数。
- [`Surface.h`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/libs/gui/include/gui/Surface.h) 与 [`Surface.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/libs/gui/Surface.cpp)：查看 AOSP `Surface` 对 `ANativeWindow` 和 BufferQueue producer 的实现。
- [`BufferQueueProducer.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/libs/gui/BufferQueueProducer.cpp) 与 [`BufferQueueConsumer.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/libs/gui/BufferQueueConsumer.cpp)：查看 slot、dequeue、queue、acquire 和 release 生命周期。
- Vulkan [`swapchain.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/vulkan/libvulkan/swapchain.cpp)、[`driver.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/vulkan/libvulkan/driver.cpp) 与 [`api.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/vulkan/libvulkan/api.cpp)：查看 Android WSI、loader 与 vendor driver 边界。
- [`NativeActivity.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/core/java/android/app/NativeActivity.java) 与 [`android_app_NativeActivity.cpp`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/core/jni/android_app_NativeActivity.cpp)：查看 lifecycle、Surface 和 input 如何交给 native callback。
- [`SurfaceFlinger.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/services/surfaceflinger/SurfaceFlinger.cpp)、[`FrameTimeline.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/services/surfaceflinger/Scheduler/FrameTimeline.cpp) 与 [`HWComposer.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/services/surfaceflinger/DisplayHardware/HWComposer.cpp)：查看 layer latch、FrameTimeline、composition 与 present / release fence。
- [AOSP Vulkan 架构](https://source.android.com/docs/core/graphics/arch-vulkan) 与 [`ANativeWindow` NDK Reference](https://developer.android.com/ndk/reference/group/a-native-window)：核对平台公开接口和 WSI 结构。
- [Android Frame Pacing / Swappy](https://developer.android.com/games/sdk/frame-pacing) 与 [Vulkan frame pacing extensions](https://developer.android.com/games/develop/vulkan/frame-pacing-extensions)：核对库级 pacing 和 Android 17 `VK_EXT_present_timing` 边界。
- [Vulkan native engine 指南](https://developer.android.com/games/develop/vulkan/native-engine-support) 与 [Vulkan WSI Reference](https://docs.vulkan.org/refpages/latest/refpages/source/VK_KHR_android_surface.html)：核对运行时能力查询、同步与 swapchain 要求。
- kernel `android17-6.18-2026-06_r6` 的 [`dma-buf.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/drivers/dma-buf/dma-buf.c)、[`sync_file.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/drivers/dma-buf/sync_file.c) 以及 [Linux dma-buf 文档](https://docs.kernel.org/6.18/driver-api/dma-buf.html)：核对固定 tag 下的共享 buffer 与 fence fd 语义。

## 11. 类型边界与常见误判

### 与标准 HWUI 的边界

标准 HWUI 由 UI Thread 更新 RenderNode / display list，再由进程内 HWUI RenderThread 和 GPU 生成窗口 buffer。Native Graphics 由应用自有 render / RHI 线程直接管理 EGL surface 或 Vulkan swapchain。两者最终都会进入 SurfaceFlinger，区别位于 producer。

### 与 SurfaceView 的边界

`SurfaceView` 描述承载结构：宿主 View 树之外有独立 child layer。Native Graphics 描述生产方式：谁 acquire、submit 和 present。同一个画面可以同时属于两种结构，独立文章仍需分别检查 SurfaceView 几何 / lifecycle 与 native render loop。

### 与软件及离屏渲染的边界

CPU `lockCanvas()` 直接写可见 Surface 属于软件 producer；GPU 先写 `HardwareBuffer` 再编码、缓存或 `setBuffer()`，属于离屏生产与消费；EGL / Vulkan render loop 持续面向可见 window swapchain 出图，属于 Native Graphics。判断点是 producer 与结果去向。

### 常见误判

| 误判 | 正确检查方式 |
|---|---|
| 出现 C++ 线程就是 Native Graphics | 确认该线程是否管理可见 Surface 的 acquire / submit / present |
| `eglSwapBuffers()` 长等于 GPU draw 慢 | 拆 driver flush、slot / fence、swap interval 和 pacing wait |
| `vkQueueSubmit()` 返回就代表 buffer ready | 对齐 GPU execution 与 producer fence signal |
| `vkQueuePresentKHR()` 返回就代表已经上屏 | 继续追 queueBuffer、SF latch、HWC 与 display present |
| `vkAcquireNextImageKHR()` 可以同步业务线程 | 使用显式 semaphore / fence；acquire 阻塞行为依赖实现状态 |
| Vulkan 一定比 GLES 快 | 比较 CPU driver overhead、GPU workload、实现质量、稳定性和 pacing |
| ANGLE 一定更慢或一定更快 | 先确认 backend，再量翻译、driver、GPU 和 pipeline 缓存 |
| Swappy 中的等待都是卡顿 | 对齐目标 slot、队列深度、present 间隔和输入延迟 |
| `SurfaceView` 上有 HUD 就一定多一个 SF layer | 引擎内 HUD 通常已画进同一 swapchain image |
| Native layer 一定走 HWC overlay | 查本帧 composition type、格式、变换、alpha 与 plane 资源 |

## 总结

Native Graphics 的主线是应用自有 render loop：EGL / GLES 通过 `eglSwapBuffers()` 交付 window buffer，Vulkan 通过 acquire、submit、present 管理 swapchain，ANGLE 可能在 GLES API 下使用 Vulkan backend，Swappy 或自研算法负责帧 pacing。它们最终都回到 `ANativeWindow`、BufferQueue、SurfaceFlinger 和 HWC。

Perfetto 中应从主体 Surface 和 producer tid 开始，逐帧对齐输入、逻辑、acquire、CPU submit、GPU completion、queue、SF latch、HWC present 与 release。只有把 producer、GPU 和显示三段分开，才能判断等待来自应用工作、GPU 执行、queue-stuffing、SurfaceFlinger readiness，还是最终 composition。

GENERATED FILE - DO NOT EDIT.
Source: docs/rendering_pipelines/S09_webview_type.md
Source SHA-256: f1e5a808491594eb73e542aea5d6a2709fa3b375f01d72c4620b9181e5f4cdae

# Android Perfetto 系列 - App 出图类型 - WebView 类型

WebView 卡顿经常跨越三个边界：网页 renderer、宿主 App 进程中的 WebView / GPU 服务、Android 窗口显示链路。标准 `android.webkit.WebView` 的主体内容通常通过 HWUI WebView functor / DrawFn 合入宿主窗口；视频、受保护内容或 provider overlay 才可能增加独立 `SurfaceControl` layer。把网页主体、媒体 overlay 和定制内核混为一条路径，Perfetto 结论很容易落错进程或落错 layer。

这篇文章以 Android 17 / API 37、`android-17.0.0_r1` 为平台源码锚点，kernel 侧以 `android17-6.18-2026-06_r6` 为锚点。Chromium WebView 是可更新 provider，必须以设备上的 provider 包名和版本为第二锚点，不能用 Android 17 平台 tag 代替 Chromium revision。

<!--more-->

## 阅读导航

### 本文目录

- 1. 两条版本线与三个执行域
- 2. 标准硬件加速路径：WebView functor
- 3. 软件绘制 fallback
- 4. 媒体与 SurfaceControl overlay
- 5. 从网页更新到屏幕的一帧
- 6. renderer 生命周期与内存压力
- 7. Perfetto 证据链
- 8. 常见瓶颈与优化方向
- 9. Android 12—17 版本演进
- 10. Android 17 与 Chromium 源码入口
- 11. 类型边界与常见误判
- 总结

### 系列文章目录

1. [Android Perfetto 系列 - App 出图类型 - 总览与识别方法](S01_rendering_types_overview.md)
2. [Android Perfetto 系列 - App 出图类型 - AOSP 标准类型](S02_aosp_standard_type.md)
3. [Android Perfetto 系列 - App 出图类型 - SurfaceView 类型](S03_surfaceview_type.md)
4. [Android Perfetto 系列 - App 出图类型 - TextureView 类型](S04_textureview_type.md)
5. [Android Perfetto 系列 - App 出图类型 - 混合出图类型](S05_mixed_rendering_type.md)
6. [Android Perfetto 系列 - App 出图类型 - 多窗口类型](S06_multi_window_type.md)
7. [Android Perfetto 系列 - App 出图类型 - Software / 离屏类型](S07_software_offscreen_type.md)
8. [Android Perfetto 系列 - App 出图类型 - Native Graphics 类型](S08_native_graphics_type.md)
9. [Android Perfetto 系列 - App 出图类型 - WebView 类型](S09_webview_type.md)
10. [Android Perfetto 系列 - App 出图类型 - Flutter 类型](S10_flutter_type.md)
11. [Android Perfetto 系列 - App 出图类型 - Camera 类型](S11_camera_type.md)
12. [Android Perfetto 系列 - App 出图类型 - Video Overlay / HWC 类型](S12_video_overlay_hwc_type.md)
13. [Android Perfetto 系列 - App 出图类型 - Game 类型](S13_game_type.md)
14. [Android Perfetto 系列 - App 出图类型 - React Native 类型](S14_react_native_type.md)

## 1. 两条版本线与三个执行域

`android.webkit.WebView` 是 Android framework API，页面引擎由 WebView provider 包实现。自 Android 5 起，AOSP WebView 已是可更新组件；同一台 Android 17 设备可以随着系统组件更新获得不同 Chromium milestone。同一个 provider 也可能通过 feature flag、GPU blocklist 和厂商配置选择不同实现。

开始分析前应记录这些信息：

- Android build 与 API level；
- 当前 WebView provider 包名、versionName、versionCode；
- 应用是否使用系统 `android.webkit.WebView`、AndroidX WebKit、定制 Chromium 或第三方内核；
- hardware acceleration、renderer multiprocess 状态、页面 URL / 场景和复现时间；
- GPU backend、WebView feature flag 与是否出现媒体 overlay。

现代 Chromium WebView 可以按三个执行域理解。

1. **宿主 App 进程**：framework WebView、provider glue、WebView browser code、UI 协调，以及 Chromium 架构文档所述的 in-process GPU service / Network Service。
2. **sandboxed renderer 进程**：Blink 执行 JavaScript、style、layout、paint，并运行 renderer / compositor 相关工作。一个 renderer 进程可以服务一个或多个 WebView，具体复用由 provider 决定。
3. **Android 显示系统**：宿主 ViewRoot、HWUI RenderThread、BLAST / BufferQueue、SurfaceFlinger、CompositionEngine 和 HWC。

这三个域之间有 IPC、task queue、GPU resource 和 fence。主线程空闲不能排除 renderer 忙；renderer 已产出 compositor frame 也不能证明宿主窗口及时消费；宿主窗口已 queue buffer 之后还要检查 SF / HWC。

## 2. 标准硬件加速路径：WebView functor

标准硬件加速 WebView 仍是 Android `View`。它参与宿主 View 的 measure、layout、invalidate、clip、alpha 和窗口生命周期，但网页像素不会由普通 `Canvas.drawText()` / `drawBitmap()` 一项项重放。provider 通过 WebView functor 把 Chromium 合成结果接入 HWUI。

Android 17 的 `WebViewFunctor.h` 同时定义 GLES 与 Vulkan 回调。HWUI 在 RenderThread 上调用 functor 的 sync / draw / postDraw 等阶段，provider 的 `AwDrawFnImpl` 再把 Chromium compositor frame 接入当前 HWUI 图形上下文。当前 HWUI backend 与 provider 支持情况共同决定走 GLES 还是 Vulkan functor 分支。

```mermaid
flowchart TD
    Input["scroll / JS / DOM / image / animation"]
    Renderer["sandboxed renderer<br/>Blink + compositor work"]
    Provider["host WebView provider<br/>browser code + in-process services"]
    GPUService["Chromium GPU service<br/>raster / resource production"]
    Frame["compositor frame / transferable resources"]
    HostUI["host main thread<br/>invalidate + traversal + display list"]
    Functor["WebView functor reference<br/>recorded into display list"]
    RT["host HWUI RenderThread<br/>sync + DrawFn consume / draw"]
    Window["host App Window buffer<br/>BLAST / queueBuffer"]
    SF["SurfaceFlinger<br/>host layer latch"]
    HWC["HWC / RenderEngine composition"]
    Display["Composer HAL / display driver"]
    Present["display present feedback"]

    Input --> Renderer --> Provider
    Provider --> GPUService --> Frame
    Input --> HostUI
    Frame --> RT
    HostUI --> Functor --> RT --> Window --> SF --> HWC
    HWC --> Display --> Present
```

主线程在 display list 中记录 functor 引用和绘制边界，重工作不等于都发生在主线程。RenderThread 执行 functor 时，如果 Chromium frame、resource import 或 GPU service 未就绪，宿主窗口帧可能在这一段等待或复用旧网页内容。

网页主体已经合入 host App Window buffer 后，SurfaceFlinger 通常只看到宿主窗口 layer。网页中的 DOM layer、CSS transform、canvas 和普通图片不会逐个变成 SF layer，HWC 也无法单独把某个 DOM 元素分配到 overlay plane。

functor 还要遵守宿主 View 属性。clip、matrix、alpha、窗口缩放和圆角会影响 HWUI 怎样调用和合成 WebView 内容。WebView 尺寸过大、长期保留不可见区域或频繁改变复杂 clip，都可能增加 tile、raster 和宿主 GPU 成本。

## 3. 软件绘制 fallback

窗口关闭硬件加速、Canvas 不是 hardware accelerated，或 provider 的硬件 draw request 未被接受时，WebView 可以走软件绘制 fallback。此时网页内容以 CPU raster 结果画入宿主软件 Canvas 或 View software layer，成本模型转向 CPU、Bitmap / shared memory 和内存带宽。

软件 fallback 仍归属于宿主 View 的绘制结果。整窗口软件绘制时，宿主 `ViewRootImpl.drawSoftware()` 最终通过 `Surface.lockCanvas()` / `unlockCanvasAndPost()` 提交 App Window buffer；单个 View software layer 时，结果先成为 Bitmap，再由宿主 HWUI 窗口消费。SurfaceFlinger 看到的依旧主要是宿主 layer。

Perfetto 中缺少 WebView GPU / DrawFn slice，同时主线程出现长时间软件 raster、Bitmap 分配或 `lockCanvas()`，才有理由怀疑 fallback。只凭低端设备或某个 CSS 特性不能断言“WebView 自动切软件”。需要结合 Canvas acceleration、provider log、调用栈和 GPU process / service 状态确认。

## 4. 媒体与 SurfaceControl overlay

网页主体的 functor 路径与网页中的视频 layer 要分开。视频解码输出、受保护内容、全屏媒体或 provider 的 overlay promotion 可以通过独立 Surface / `SurfaceControl` 进入系统，使宿主窗口之外多出 child layer。

Android 17 的 `WebViewFunctor` 回调包含 overlay data、merge transaction 和 remove overlays 等接口。它允许 provider 在 HWUI draw 周期中协调 overlay 的几何与事务；这项能力不能推导出整个网页都绕过宿主窗口。常见结构是“网页 UI 在 host buffer，视频在独立 layer”。

```mermaid
sequenceDiagram
    participant Renderer as Web renderer
    participant GPU as Provider / GPU service
    participant Host as Host UI + HWUI RenderThread
    participant Overlay as SurfaceControl media layer
    participant SF as SF FrontEnd / CompositionEngine
    participant HWC as Composer HAL / Display driver

    Renderer->>GPU: compositor frame metadata / resources
    GPU->>Host: DrawFn 可消费的网页帧
    Host->>Host: functor draw into host buffer
    Host->>SF: host window buffer transaction
    opt 页面存在媒体或受保护内容 overlay
        GPU->>Overlay: decoded media buffer + acquire fence
        Host->>Overlay: merge geometry / crop / visibility transaction
        Overlay->>SF: 媒体 buffer / 状态 transaction
    end
    SF->>SF: build host + overlay layer snapshot
    SF->>HWC: choose DEVICE or CLIENT per layer
    HWC-->>SF: display present + per-layer release fences
```

overlay 的 buffer ready 与宿主几何 ready 是两个条件。视频 producer 晚到可能沿用旧视频帧；宿主滚动 / transform transaction 晚到会造成位置不同步；HWC plane 不足、复杂裁剪、透明度或 HDR / SDR 组合变化又可能让视频从 DEVICE 切到 CLIENT composition。

全屏视频还可能由应用通过 `WebChromeClient.onShowCustomView()` 放入单独的 native View / Surface 容器。此时 trace 中的关键 layer 可能属于应用创建的播放器 View，不应继续把所有成本归到 WebView functor。

`TextureView`、`SurfaceView` 和 `ImageReader` 也可能出现在定制浏览器内核或应用包装层中，但它们不是标准 `android.webkit.WebView` 的五个可互换主渲染模式。看到这些对象时，要按实际 owner 和调用栈归类，不要仅凭“内容来自网页”贴 WebView 标签。

## 5. 从网页更新到屏幕的一帧

一帧可以拆成六段，每段都有独立迟到方式。

1. **网页状态更新**：JavaScript、DOM、style、layout、paint invalidation、图片解码或滚动改变页面内容。
2. **renderer 合成准备**：Blink / compositor 生成 frame，raster worker 准备 tile，跨进程把 frame / resource 信息送到 browser 侧。
3. **宿主 invalidate 与 traversal**：WebView 通知宿主需要 redraw，主线程在 `Choreographer#doFrame()` 中执行 traversal 并记录 functor。
4. **RenderThread functor draw**：HWUI 同步 View 树状态，调用 DrawFn，等待或导入 Chromium resource，把网页与其他 View 合入 host buffer。
5. **窗口提交**：HWUI 完成 GPU 工作，把 host buffer 与 producer fence 通过 BLAST / BufferQueue 交给 SurfaceFlinger。
6. **系统显示**：SF latch host layer 和可选 media overlay，HWC / RenderEngine 完成 composition，display present fence 标记显示栈 present 边界。

这六段并非严格串行。renderer 可以提前生产，宿主也可能在网页 frame 未更新时重画遮罩；GPU 工作跨 CPU task 异步执行。分析必须用 frame / buffer / token 对齐，不能把相邻 slice 自动当作同一帧。

主 WebView 内容经 host layer 提交时，标准 App FrameTimeline 更容易覆盖宿主窗口，很少单独给出“网页 frame”的 expected / actual。Chromium 内部 frame id、WebView trace event 和 host FrameTimeline 要做关联。媒体 overlay 还可能拥有自己的 buffer frame number 与 fence。

## 6. renderer 生命周期与内存压力

WebView renderer 进程可能因为 crash 或系统回收而消失。官方 Termination Handling API 要求：应用若选择继续运行，原 WebView 实例不能复用，需要从 hierarchy 移除、destroy，再创建新实例。忽略 `onRenderProcessGone()` 会把后续白屏、重复 crash 或无响应误判成渲染性能问题。

`setRendererPriorityPolicy()` 可以在 multiprocess 模式下调整 renderer importance。把不可见 WebView 的 renderer importance 降低，有利于系统回收内存，但应用必须具备 renderer 消失后的恢复路径。页面切后台后白屏重载，先查 renderer OOM / process death，再查绘制链路。

WebView 首次初始化本身很重，默认可能在首次调用 `android.webkit` / `androidx.webkit` API 或 inflate WebView 时隐式发生在 UI 线程。首屏卡顿应把 provider load、native library、Chromium startup、renderer 创建、网络和首帧 raster 分开。稳态滚动 trace 无法解释冷启动成本。

大页面可能同时占用 DOM / JS heap、decoded image、Skia resource、GPU texture、tile 缓存和宿主 graphics memory。内存压力会触发 raster eviction、重新解码、GC、renderer 回收或 dma-buf 分配抖动。kernel 6.18 侧可以补看 page fault、direct reclaim、`kswapd`、zram、PSI memory、dma-buf 和 GPU driver memory wait。

## 7. Perfetto 证据链

### 第一步：固定 provider 与进程

先记录 provider 版本，再在 trace 中找宿主进程、sandboxed renderer 进程和宿主进程内的 Chromium / GPU service 线程。provider 更新后线程名和 slice 会变化，因此线程名只能做入口，进程关系、调用栈和 trace category 更重要。

### 第二步：确认最终 layer 结构

检查 SurfaceFlinger layer tree：只有 host App Window，通常表示网页主体已通过 functor 合入；额外出现视频 / protected / WebView child layer，再检查其 parent、buffer format、dataspace、crop 和 owner。没有证据时，不要假设 TextureView、SurfaceView 或 ImageReader 中转。

### 第三步：从网页到宿主逐段对齐

| 现象 | 更可能的瓶颈 | 需要补看的证据 |
|---|---|---|
| renderer main 长任务 | JavaScript、style、layout、paint | renderer task、Long Task、DevTools、CPU profile |
| raster worker / image decode 晚 | tile raster、图片解码、缓存未命中 | worker queue、Skia / decode slice、内存与 I/O |
| frame 已到 browser 侧，宿主很晚才 draw | invalidate / traversal、主线程抢占 | host `doFrame`、ViewRoot、Runnable latency |
| RenderThread 在 WebView DrawFn 段变长 | resource import、functor sync/draw、GPU service 或 GPU 工作 | DrawFn slice、GPU queue、fence、backend |
| host `queueBuffer` 正常，SF 没有及时换帧 | acquire fence、latch / transaction 或 display 问题 | host layer、FrameTimeline、SF/HWC |
| 网页 UI 正常，视频卡或位置漂移 | media producer / overlay transaction | video layer buffer、decoder fence、geometry transaction |

### 第四步：区分 CPU 等待与 CPU 工作

renderer 或 host 线程 slice 很长时，结合线程状态判断 Running、Runnable、Sleeping 和 blocked。Runnable 很长是调度延迟；Sleeping / futex 可能在等 IPC、task 或 fence；Running 才继续看 JavaScript、layout、paint 或 native CPU 栈。只量 slice wall time 会把等待算成计算。

### 第五步：验证最终显示

宿主 functor 路径查看 host App Window 的 `BufferTX - <layerName>`、FrameTimeline、SF latch、composition type 和 display present fence。媒体 overlay 路径还要逐层查看 buffer ready、transaction ready、HWC DEVICE / CLIENT 变化与 release fence。网页内部 compositor frame ready 不是最终上屏证据。

## 8. 常见瓶颈与优化方向

网页侧优先控制长 JavaScript task、强制同步 layout、过大的 DOM、频繁 style invalidation、巨幅图片、复杂 filter / blend、全屏 canvas 重绘和过量动画。Chrome DevTools 能回答 DOM / JS / style 问题，Perfetto 更适合把这些成本与 Android 调度、GPU、宿主窗口和显示端对齐。

宿主侧应避免在 WebView 上叠加频繁变化的大面积透明层、复杂 clip、软件 layer 或每帧 resize。WebView 与 Compose / View overlay 混合时，要确认宿主 traversal 和 RenderThread 是否因其他 UI 抢占 deadline。把网页优化到 5 ms，而宿主主线程仍晚 20 ms，用户看到的帧仍然晚。

首屏优化要减少隐式 WebView startup 落在关键 UI 操作上，合理安排 provider 初始化、renderer 创建和网络预热。预热会增加进程和内存常驻，必须以真实启动路径和后台资源预算评估。

视频问题则看 codec output、surface buffer、HDR / protected usage、overlay geometry 与 HWC plane。降低 DOM 成本无法修复 decoder fence 晚；调整播放器 buffer 也无法修复宿主主线程滚动 transaction 晚。

## 9. Android 12—17 版本演进

WebView 的演进要同时保留“平台集成线”和“provider 更新线”。下面各版本描述 Android 平台边界；Chromium milestone、Skia backend、feature flag 和安全修复必须另按设备 provider 核对。

### Android 12 / API 31

Android 12 上，现代 WebView 已采用可更新 Chromium provider，并具备 sandboxed renderer、宿主 HWUI functor 与独立 renderer 生命周期管理。平台显示端进入 BLAST / FrameTimeline 诊断基线。WebView 主体仍通常合入 host App Window，不能因为 Chromium 自带 compositor 就把它当成独立 SF layer。

### Android 13 / API 33

Android 13 增加公开的 algorithmic darkening 控制，可能改变网页颜色处理与 raster 结果，但不改变 functor → host buffer 的基本拓扑。显示端 HWC HAL 进入 AIDL 时代；WebView provider 仍按自身发布节奏更新，Android 13 版本号不能唯一确定 Chromium 实现。

### Android 14 / API 34

标准 WebView 的 framework / provider / renderer / HWUI 分层保持稳定。Android 14 的平台图形新增能力不会自动把 WebView 主体改成 `HardwareBufferRenderer` 或独立 `SurfaceControl`。这一阶段的差异更多来自 provider milestone、GPU blocklist、Skia / Chromium feature flag 和 OEM WebView 包。

### Android 15 / API 35

Android 15 支持 16 KB page size 设备。宿主 App、WebView provider 与其 native libraries 都需要兼容对应 ELF / APK 对齐；不兼容时常见的首个表现是加载或运行失败，不能归因于 functor 性能。平台 FrameTimeline 与 transaction 反馈继续增强，网页主体仍应围绕 host window token 分析。

### Android 16 / API 36

Android 16 的 GPU syscall filtering 对面向 target 36 的应用生效，但官方支持的 GLES / Vulkan 路径不受破坏。定制内核、注入层、非标准 GPU ioctl 或陈旧调试组件需要额外验证。WebView provider 可更新属性和标准 functor 主线保持不变。

### Android 17 / API 37

Android 17 的平台源码锚点中，`WebViewFunctor` 已明确包含 GLES / Vulkan draw callback、overlay transaction 协调和 rendering thread reporting 等边界；SurfaceFlinger 后半段按 FrontEnd layer snapshot、CompositionEngine 与 AIDL Composer 理解。它描述平台如何承接 provider，不固定设备上的 Chromium milestone。

截至本文锚点，WebView 文档与 provider 仍持续独立更新。复现报告必须同时写 `android-17.0.0_r1` 对应的平台语义和设备实际 provider 版本，否则同为 Android 17 的两台设备可能拥有不同 Chromium 行为。

kernel 统一到 `android17-6.18-2026-06_r6` 后，网页主窗口与媒体 overlay 仍沿用 dma-buf、dma-fence / sync_file 语义；具体 GPU service、vendor driver 与 codec driver 的调度要用设备 tracepoint 补齐。

## 10. Android 17 与 Chromium 源码入口

### Android 平台

- [`WebView.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/core/java/android/webkit/WebView.java) 与 [`WebViewFactory.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/core/java/android/webkit/WebViewFactory.java)：查看 framework API 如何选择并加载 provider。
- [`WebViewDelegate.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/core/java/android/webkit/WebViewDelegate.java) 与 [`WebViewFunctor.h`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/libs/hwui/private/hwui/WebViewFunctor.h)：查看 framework / HWUI 提供给 provider 的 functor 边界。
- [`WebViewFunctorManager.cpp`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/libs/hwui/WebViewFunctorManager.cpp) 与 [`RenderThread.cpp`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/libs/hwui/renderthread/RenderThread.cpp)：查看 functor 生命周期和 RenderThread 执行环境。
- [`SurfaceFlinger.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/services/surfaceflinger/SurfaceFlinger.cpp)、[`FrameTimeline.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/services/surfaceflinger/Scheduler/FrameTimeline.cpp) 与 [`HWComposer.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/services/surfaceflinger/DisplayHardware/HWComposer.cpp)：查看 host / overlay layer 的最终显示。

### WebView provider

- [Chromium WebView architecture](https://chromium.googlesource.com/chromium/src/+/refs/heads/main/android_webview/docs/architecture.md)：查看 browser code、renderer process、in-process services 与可更新包结构。
- [`AwContents.java`](https://chromium.googlesource.com/chromium/src/+/refs/heads/main/android_webview/java/src/org/chromium/android_webview/AwContents.java) 与 [`AwDrawFnImpl`](https://chromium.googlesource.com/chromium/src/+/refs/heads/main/android_webview/browser/gfx/aw_draw_fn_impl.cc)：查看当前上游 functor 与 compositor frame consumer。排障时应切到设备 provider 对应 revision。
- [WebView 官方开发指南](https://developer.android.com/develop/ui/views/layout/webapps/webview)、[renderer 管理](https://developer.android.com/develop/ui/views/layout/webapps/managing-webview) 与 [startup 优化](https://developer.android.com/develop/ui/views/layout/webapps/optimize-webview-startup)：核对公开生命周期和启动要求。
- kernel `android17-6.18-2026-06_r6` 的 [`dma-buf.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/drivers/dma-buf/dma-buf.c)、[`sync_file.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/drivers/dma-buf/sync_file.c) 以及 [Linux dma-buf 文档](https://docs.kernel.org/6.18/driver-api/dma-buf.html)：核对固定 tag 下的 buffer / fence 基础语义。

## 11. 类型边界与常见误判

### 与标准 HWUI 的边界

WebView 主体最终复用宿主 HWUI 窗口，但 producer 前面还有 Blink、renderer compositor、raster 和 Chromium GPU service。只按普通 View 的 measure / layout / draw 分析，会漏掉网页侧和 functor 侧。

### 与 SurfaceView / Video Overlay 的边界

网页中的视频或全屏 custom view 可以增加独立 Surface layer。此时网页 UI 仍可能走 host functor，视频 buffer 走 media layer，两条路径必须分别检查 producer、fence 和 transaction。

### 与 TextureView / 离屏路径的边界

定制内核可以选择 TextureView、ImageReader 或 `HardwareBuffer` 中转。标准 WebView 没有公开 API 让应用在五种渲染目标之间随意切换。trace 中只有出现对应 BufferQueue、SurfaceTexture 或 ImageReader owner 后，才按定制路径分析。

### 常见误判

| 误判 | 正确检查方式 |
|---|---|
| Android 17 唯一确定 WebView 源码 | 同时记录并匹配 provider 包版本 / Chromium revision |
| WebView 所有工作都在宿主主线程 | 同看 sandboxed renderer、宿主 Chromium 线程、GPU service 与 HWUI RT |
| Chromium 有 compositor，所以网页一定是独立 SF layer | 标准主体通常经 functor 合入 host App Window |
| DOM layer 对应 SurfaceFlinger layer | DOM / cc layer 通常已在 Chromium / HWUI 内合成 |
| 看到额外 layer 就是整个 WebView 独立出图 | 先判断是否为视频、protected content 或 custom view |
| renderer frame ready 表示用户已看到 | 继续追 host draw、queueBuffer、SF latch 与 display present |
| 主线程空闲说明 WebView 没问题 | renderer、raster、GPU service 或 RenderThread 仍可能迟到 |
| renderer 被系统回收后可以复用原 WebView | 按官方要求 destroy 旧实例并新建 |
| provider 更新只影响网页功能 | Chromium、Skia、GPU backend、thread / trace slice 都可能变化 |

## 总结

WebView 的标准显示主线是：sandboxed renderer 准备网页内容，宿主进程中的 provider / GPU service 交付 compositor frame，主线程记录 WebView functor，HWUI RenderThread 把网页合入 App Window，随后经 BLAST、SurfaceFlinger 和 HWC 显示。视频、受保护内容或全屏媒体可以另外生成 `SurfaceControl` layer，但它们不能代表整个网页主体。

Perfetto 分析要同时固定 Android 平台版本与 WebView provider 版本，再按 renderer、host functor、host window、media overlay 和 display 五层对齐证据。这样才能区分网页计算晚、raster 晚、IPC / resource 晚、宿主窗口晚与 SurfaceFlinger / HWC 晚。

GENERATED FILE - DO NOT EDIT.
Source: docs/rendering_pipelines/S10_flutter_type.md
Source SHA-256: 1d342817546f98db9f328f8552f0ab2465db50f4d550b95212ac6b9cc39daacf

# Android Perfetto 系列 - App 出图类型 - Flutter 类型

Flutter 页面不能只用“Dart UI thread + Raster thread”概括。最终显示形态由三组配置共同决定：Flutter root 使用哪种 Android render target，插件外部纹理由谁生产，PlatformView 采用哪种合成策略。同一页面可以同时出现 Flutter root Surface、相机 external texture、原生地图 View 和系统 overlay。

这篇文章以 Android 17 / API 37、`android-17.0.0_r1` 为平台源码锚点，kernel 侧以 `android17-6.18-2026-06_r6` 为锚点。Flutter framework、engine 和 Flutter Android embedding 随 App 一起发布，必须另行记录 Flutter 版本、engine revision、Impeller backend 与插件版本。

<!--more-->

## 阅读导航

### 本文目录

- 1. Flutter 一帧的公共前半段
- 2. Root RenderMode：surface、texture、image
- 3. 插件 external texture 与 SurfaceProducer
- 4. PlatformView：TLHC、HC 与 HCPP
- 5. Fence、FrameTimeline 与最终显示
- 6. Perfetto 证据链
- 7. 常见瓶颈与优化方向
- 8. Android 12—17 与 Flutter 版本演进
- 9. Android 17 与 Flutter 源码入口
- 10. 类型边界与常见误判
- 总结

### 系列文章目录

1. [Android Perfetto 系列 - App 出图类型 - 总览与识别方法](S01_rendering_types_overview.md)
2. [Android Perfetto 系列 - App 出图类型 - AOSP 标准类型](S02_aosp_standard_type.md)
3. [Android Perfetto 系列 - App 出图类型 - SurfaceView 类型](S03_surfaceview_type.md)
4. [Android Perfetto 系列 - App 出图类型 - TextureView 类型](S04_textureview_type.md)
5. [Android Perfetto 系列 - App 出图类型 - 混合出图类型](S05_mixed_rendering_type.md)
6. [Android Perfetto 系列 - App 出图类型 - 多窗口类型](S06_multi_window_type.md)
7. [Android Perfetto 系列 - App 出图类型 - Software / 离屏类型](S07_software_offscreen_type.md)
8. [Android Perfetto 系列 - App 出图类型 - Native Graphics 类型](S08_native_graphics_type.md)
9. [Android Perfetto 系列 - App 出图类型 - WebView 类型](S09_webview_type.md)
10. [Android Perfetto 系列 - App 出图类型 - Flutter 类型](S10_flutter_type.md)
11. [Android Perfetto 系列 - App 出图类型 - Camera 类型](S11_camera_type.md)
12. [Android Perfetto 系列 - App 出图类型 - Video Overlay / HWC 类型](S12_video_overlay_hwc_type.md)
13. [Android Perfetto 系列 - App 出图类型 - Game 类型](S13_game_type.md)
14. [Android Perfetto 系列 - App 出图类型 - React Native 类型](S14_react_native_type.md)

## 1. Flutter 一帧的公共前半段

Android embedding 从 `Choreographer` 获得 vsync 时间，经 `VsyncWaiter` 交给 engine。Dart framework 在 frame callback 中执行 animation、build、layout、paint，生成 layer tree / display list；engine rasterizer 再用 Impeller 或旧 Skia backend 把场景转成 GPU 工作。

Flutter 3.29 起，Android 和 iOS 默认合并 UI thread 与 platform thread：Dart UI work 运行在 Android platform thread。Raster thread 仍负责栅格化与 GPU 提交。看到新版 trace 时，不能继续寻找固定名称的独立 Flutter UI thread；平台消息、Android callback 和 Dart frame work 可能在同一线程竞争 deadline。

```mermaid
flowchart TD
    Vsync["Android Choreographer<br/>VsyncWaiter"]
    UI["platform + Dart UI thread<br/>animation / build / layout / paint"]
    LayerTree["Flutter layer tree / display list"]
    Raster["Raster thread<br/>Impeller or legacy renderer"]
    External["plugin external texture<br/>SurfaceProducer / image input"]
    Classify["root RenderMode<br/>+ PlatformView strategy"]
    RootSurface["FlutterSurfaceView<br/>independent root Surface"]
    RootTexture["FlutterTextureView / FlutterImageView<br/>texture or image result"]
    HostHWUI["Android host HWUI<br/>sample / compose into App Window"]
    HostWindow["host App Window BLAST"]
    TLHC["PlatformView TLHC<br/>native View → texture input"]
    HCHCPP["PlatformView HC / HCPP<br/>multiple Android surfaces<br/>HCPP: API 34+ opt-in + Vulkan"]
    SF["SurfaceFlinger<br/>latch visible layer set"]
    HWC["HWC / RenderEngine composition"]
    Display["Composer HAL / display driver"]
    Present["display present feedback"]

    Vsync --> UI --> LayerTree --> Raster --> Classify
    External --> Raster
    TLHC --> Raster
    Classify --> RootSurface --> SF
    Classify --> RootTexture --> HostHWUI --> HostWindow --> SF
    Classify --> HCHCPP --> SF
    SF --> HWC --> Display --> Present
```

图中的 Classify 不能省略。Raster 完成 GPU 工作只表示某个 target 的内容接近 ready；root 是独立 Surface 还是宿主纹理、external texture 是否更新、PlatformView 是否另有 layer，决定后续 fence 和 layer 数量。

## 2. Root RenderMode：surface、texture、image

Android embedding 的 `RenderMode` 当前包含 `surface`、`texture` 和 `image`。它描述 Flutter root 内容接到哪种 Android View，不描述 PlatformView 怎样嵌入。

### `RenderMode.surface`

`FlutterSurfaceView` 背后是 `SurfaceView` 与独立 Surface。engine 直接面向这条 BufferQueue 生产 Flutter root buffer，Raster / GPU completion fence 随 queue 进入 SurfaceFlinger。宿主 Activity 窗口仍负责 ViewRoot、输入、系统栏和其他 Android View，但纯 Flutter 主体通常对应独立 child layer。

这条路径少一次回宿主纹理采样，通常是 opaque Flutter 页面首选。代价是独立 layer 的 z-order、alpha、生命周期和窗口 transition 需要 embedding 协调。Surface 创建、销毁或尺寸变化时，engine 必须及时切换输出 target。

### `RenderMode.texture`

`FlutterTextureView` 让 engine 先写 `SurfaceTexture`。宿主 HWUI 在下一次窗口 draw 中取得最新 texture image，把 Flutter 内容采样进 host App Window buffer，再由宿主 BLAST / BufferQueue 提交。

这条路径便于透明背景和 View hierarchy 变换，但多了 producer SurfaceTexture 与 host window 两段节拍。Flutter buffer ready、`onFrameAvailable` / invalidate、宿主 traversal、HWUI texture acquire 和 host queue 任何一段迟到，都会影响最终帧。SurfaceFlinger 通常只看到 host window，不会看到独立 Flutter root layer。

### `RenderMode.image`

`FlutterImageView` 使用 `ImageReader` 接收 engine 输出，再把 image 作为 Android View 内容画回宿主。它主要服务 render surface 切换等特定 embedding 场景，不能当作普通页面的默认高性能模式。分析时要额外检查 Image acquire、`HardwareBuffer` / Bitmap 包装、宿主 draw 和 image release。

三种 root 路径的关键差异如下。

| RenderMode | 中间对象 | SF 主要可见对象 | 常见等待 |
|---|---|---|---|
| surface | 独立 Surface buffer | Flutter root child layer | root dequeue / GPU fence / SF latch |
| texture | SurfaceTexture image | host App Window | texture acquire + host traversal / draw |
| image | ImageReader image | host App Window | image acquire / copy 或采样 + host draw |

## 3. 插件 external texture 与 SurfaceProducer

相机、视频、地图或 native renderer 可以通过 `TextureRegistry` 向 Flutter scene 提供 external texture。producer 先写 Android Surface，Flutter Raster 在合成 root scene 时采样最新 image，最终仍按当前 root RenderMode 输出。

这形成两级 producer：插件 producer 负责 camera / codec / GL buffer，Flutter engine 负责采样并生成 root buffer。插件帧率和 Flutter 帧率可以不同。Flutter 每帧都画不代表相机每帧都更新；相机 buffer ready 也不代表 Flutter 已在下一帧采样。

Flutter 3.24 稳定的 `TextureRegistry.SurfaceProducer` 让 engine 根据平台与 API level 选择 backing implementation。在当前 Flutter 源码里，未强制 GL texture、API 29+ 且设备不在已知 HardwareBuffer 缺陷列表时，`createSurfaceProducer()` 优先创建 `ImageReaderSurfaceProducer`；否则回退到 `SurfaceTextureSurfaceProducer`。

这两个 backing 的契约不同，trace 里不能只写一个抽象的 `SurfaceProducer`。`ImageReaderSurfaceProducer` 会在后台 reset / 内存压力路径触发 `onSurfaceCleanup()`，恢复时再触发 `onSurfaceAvailable()`；插件需要重新取得 surface 并补画当前内容。`onSurfaceDestroyed()` 只是旧别名，当前源码建议使用 `onSurfaceCleanup()`。`SurfaceTextureSurfaceProducer` 的 `setCallback()` 在源码中为空，不会收到同样的平台清理通知。

使用相机预览时还要检查 `handlesCropAndRotation()`。当前 `ImageReaderSurfaceProducer` 返回 `false`，`SurfaceTextureSurfaceProducer` 返回 `true`：前者可能需要插件或 Flutter widget 修正传感器方向、裁剪与设备方向，后者更接近旧 SurfaceTexture 语义。方向错误属于 producer / embedding 契约问题，与 SurfaceFlinger transform 不是同一层。

## 4. PlatformView：TLHC、HC 与 HCPP

PlatformView 用于在 Flutter 页面中嵌入原生 Android View，例如 WebView、地图和广告。Flutter widget tree 与 Android View hierarchy 是两套树，合成策略决定谁被转成 texture、谁保留为 Android View。

### Texture Layer Hybrid Composition（TLHC）与旧 Virtual Display

TLHC 把原生 View 的绘制结果放进 Flutter 可采样 texture，再由 Flutter scene 合入 root target。优点是 Flutter transform、clip 和 opacity 更容易保持；代价是额外 buffer、invalidate、texture acquire 和输入 / accessibility 桥接。包含 `SurfaceView` 的平台控件可能受限，因为独立 Surface 内容无法像普通 View 像素一样自然重定向。

旧 Virtual Display 路径也会把平台 View 放进虚拟显示和中转 Surface，链路更长，可能增加 buffer、内存和延迟。具体是否使用要看 Flutter / plugin 版本，不能只凭 `AndroidView` 推断。

### Hybrid Composition（HC）

HC 让平台 View 按 Android View 正常绘制，Flutter 内容放入 texture / overlay 后由 Android / SurfaceFlinger 组合。原生 View fidelity 较好，但 Flutter root、Flutter overlay、host window 和 Surface-backed child 可能形成多条提交节拍。平台 View 与 Flutter overlay 任一方迟到，都可能出现错位或旧内容。

### Hybrid Composition++（HCPP）

Flutter 3.44 起提供实验性 opt-in HCPP，要求 Android API 34+ 且设备可用 Vulkan。不满足条件时会回退到应用原先配置的平台 View 策略。HCPP 使用新的 transaction synchronization 改善旧 HC 的合成与同步问题，但不能假设启用后页面只剩一个 layer。

HCPP 是 Flutter 版本能力，Android 14 / 15 / 16 / 17 本身不会自动开启。报告中应同时写明 Flutter 3.44+、manifest / run flag、Vulkan capability 和实际 fallback 结果。

## 5. Fence、FrameTimeline 与最终显示

`RenderMode.surface` 的 root buffer 有自己的 producer fence 和 layer release fence；`texture` / `image` 路径先有中间 image ready / release，再由宿主窗口生成新的 GPU completion fence；PlatformView 与 overlay 还会引入各自 buffer 和 transaction。

SurfaceFlinger 在 Android 17 FrontEnd 中处理这些状态，生成本轮 layer snapshot。CompositionEngine 再与 HWC 协商 DEVICE / CLIENT composition；需要 CLIENT 时，RenderEngine 生成 client target。`presentAndGetReleaseFences()` 取得 display present fence 和 per-layer release fence。PresentSucceeded 快路径已经执行 present，后面不能再重复计算一次 present。

FrameTimeline token 也按输出对象区分。宿主 App Window、Flutter root Surface 和独立 PlatformView layer 可能拥有不同 frame number / token，external texture 的中间帧甚至没有标准 App FrameTimeline。应使用 engine frame id、texture id、buffer id、layer id 和实际时间建立关联。

kernel `android17-6.18-2026-06_r6` 下，root buffer、external texture 与 PlatformView buffer 都依赖 dma-buf 共享和 dma-fence / sync_file 同步。GPU driver、codec、camera 与 HWC 的 fence wait 必须结合具体设备 tracepoint 解释。

## 6. Perfetto 证据链

### 第一步：固定双版本与配置

记录 Android build、Flutter SDK / engine revision、Impeller 是否启用及 backend、root RenderMode、PlatformView API、HCPP flag 和插件版本。Flutter 升级可能改变线程模型与 Surface backing，同一 Android 版本上的 trace 不能直接横比。

### 第二步：画出实际对象树

从 Android View hierarchy 与 SurfaceFlinger layer tree 确认：root 是 `FlutterSurfaceView` 还是 host texture，是否存在 PlatformView、Flutter overlay、视频 / 相机 Surface。对象树确定后再选线程和 fence，避免把 external texture 的 producer 当作 Flutter root producer。

### 第三步：对齐 Flutter 帧

| 现象 | 更可能的瓶颈 | 补看证据 |
|---|---|---|
| platform / Dart thread 晚 | build、layout、paint、platform message、线程合并竞争 | Flutter frame event、CPU Running / Runnable、callback |
| Raster thread 晚 | display list raster、shader、texture upload、GPU submit | Raster event、Impeller / Skia、GPU queue |
| Raster 已提交，GPU fence 晚 | GPU workload、pipeline、带宽、频率 / thermal | GPU stage、counter、frequency、fence |
| external texture 没更新 | camera / codec / plugin producer 晚或 Surface 已重建 | texture id、producer queue、SurfaceProducer callback |
| texture root 有新帧，host window 晚 | TextureView acquire、host traversal / RenderThread | SurfaceTexture、ViewRoot、host `DrawFrame` |
| PlatformView 与 Flutter 错位 | 两套 traversal / transaction 不同步 | host vsync、Flutter frame、overlay transaction、layer latch |

### 第四步：验证系统显示

`surface` 路径看 Flutter root layer 的 buffer update、SF latch、composition type 和 present；`texture` / `image` 路径看 host App Window；HC / HCPP 再逐层检查 platform view 和 overlay。Dart frame 标为完成，只说明 framework 交出 layer tree，不能作为上屏时间。

## 7. 常见瓶颈与优化方向

Dart / platform thread 侧常见成本是 widget rebuild 范围过大、同步 layout、复杂 paint、频繁 platform channel、JSON / image decode 和 merged thread 下的 Android callback 竞争。先用 Flutter frame event 定位 UI phase，再用 Perfetto 区分 Running 与 Runnable。

Raster / GPU 侧常见成本是过量 saveLayer、blur、shader / pipeline 首次创建、大图上传、external texture 同步和高分辨率 overdraw。Impeller 减少运行时 shader 编译抖动，不会消除昂贵的像素工作与内存带宽。

PlatformView 性能问题先评估合成策略。TLHC 可能增加 texture 中转，HC 可能增加多 layer 同步，HCPP 仍处于实验阶段并有已知限制。不存在对所有 View 和设备都最优的固定模式，应以交互、变换 fidelity、帧率、输入延迟和内存共同评估。

## 8. Android 12—17 与 Flutter 版本演进

两条演进线必须分开：Android 决定 Surface、HWUI、SF / HWC 和 kernel 语义；Flutter 决定 engine、thread、renderer、embedding 与 PlatformView 策略。

### Android 12 / API 31

现代 SurfaceView / TextureView、BLAST 与 FrameTimeline 已形成当前分析基线。运行在 Android 12 的 Flutter App 可以携带不同 engine，不能用 OS 版本推断 Skia / Impeller、root RenderMode 或 PlatformView 实现。

### Android 13 / API 33

显示端进入 AIDL HWC HAL，并增加单 layer 简单 buffer update 的 AutoSingleLayer 能力。它不会替 Flutter 自动同步 root、host 与 PlatformView 多 layer。Flutter engine 和插件仍按 App 版本发布。

### Android 14 / API 34

API 34 是后来 HCPP 所需的最低 Android 版本，只满足平台 transaction synchronization 前提。只有 Flutter 3.44+、显式 opt-in、Vulkan 可用且未回退时，页面才会使用 HCPP。

### Android 15 / API 35

Android 15 支持 16 KB page size 设备，Flutter engine、AOT library 和所有 native plugin 都要满足 ELF / APK 对齐。Flutter 3.27 同期把 Impeller 设为 Android API 29+ 默认 renderer；这是 Flutter release 决策，Android 15 不会替旧 App 自动升级 engine。

### Android 16 / API 36

GPU syscall filtering 不破坏受支持的 GLES / Vulkan API，但定制 engine、注入层和陈旧 native plugin 需要测试。Flutter 3.29 起默认合并 UI / platform thread，运行在 Android 16 的旧 Flutter App 仍可能保留旧线程模型。

### Android 17 / API 37

平台锚点统一到 `android-17.0.0_r1`，显示端按 FrontEnd snapshot、CompositionEngine 和 AIDL Composer 分析。当前 Flutter 3.44 文档中 HCPP 仍为实验性 opt-in；`SurfaceProducer`、Impeller 和 thread merge 均需按 App engine revision 核对。kernel 统一到 `android17-6.18-2026-06_r6` 后，再结合具体 GPU / camera / codec driver 补充 fence 与内存证据。

## 9. Android 17 与 Flutter 源码入口

- Flutter 源码链接固定到 `8a9f61cfd67396fb2f9afc3cd7854035e9cd6fc2`，用于复核当前文档语义；实际线上 App 仍要回到它携带的 engine revision。
- Flutter [`RenderMode.java`](https://github.com/flutter/flutter/blob/8a9f61cfd67396fb2f9afc3cd7854035e9cd6fc2/engine/src/flutter/shell/platform/android/io/flutter/embedding/android/RenderMode.java)、[`FlutterSurfaceView.java`](https://github.com/flutter/flutter/blob/8a9f61cfd67396fb2f9afc3cd7854035e9cd6fc2/engine/src/flutter/shell/platform/android/io/flutter/embedding/android/FlutterSurfaceView.java)、[`FlutterTextureView.java`](https://github.com/flutter/flutter/blob/8a9f61cfd67396fb2f9afc3cd7854035e9cd6fc2/engine/src/flutter/shell/platform/android/io/flutter/embedding/android/FlutterTextureView.java) 与 [`FlutterImageView.java`](https://github.com/flutter/flutter/blob/8a9f61cfd67396fb2f9afc3cd7854035e9cd6fc2/engine/src/flutter/shell/platform/android/io/flutter/embedding/android/FlutterImageView.java)：核对 root target。
- [`FlutterRenderer.java`](https://github.com/flutter/flutter/blob/8a9f61cfd67396fb2f9afc3cd7854035e9cd6fc2/engine/src/flutter/shell/platform/android/io/flutter/embedding/engine/renderer/FlutterRenderer.java)、[`TextureRegistry.java`](https://github.com/flutter/flutter/blob/8a9f61cfd67396fb2f9afc3cd7854035e9cd6fc2/engine/src/flutter/shell/platform/android/io/flutter/view/TextureRegistry.java)、[`SurfaceTextureSurfaceProducer.java`](https://github.com/flutter/flutter/blob/8a9f61cfd67396fb2f9afc3cd7854035e9cd6fc2/engine/src/flutter/shell/platform/android/io/flutter/embedding/engine/renderer/SurfaceTextureSurfaceProducer.java) 与 [Surface plugins migration](https://docs.flutter.dev/release/breaking-changes/android-surface-plugins)：核对 external texture / `SurfaceProducer` backing、生命周期与 crop / rotation 契约。
- [`PlatformViewsController.java`](https://github.com/flutter/flutter/blob/8a9f61cfd67396fb2f9afc3cd7854035e9cd6fc2/engine/src/flutter/shell/platform/android/io/flutter/plugin/platform/PlatformViewsController.java)、[`PlatformViewsController2.java`](https://github.com/flutter/flutter/blob/8a9f61cfd67396fb2f9afc3cd7854035e9cd6fc2/engine/src/flutter/shell/platform/android/io/flutter/plugin/platform/PlatformViewsController2.java) 与 [PlatformView / HCPP 文档](https://docs.flutter.dev/platform-integration/android/platform-views)：核对 TLHC、HC、HCPP 与回退。
- [Flutter architecture](https://docs.flutter.dev/resources/architectural-overview) 与 [Impeller](https://docs.flutter.dev/perf/impeller)：核对 Flutter 3.29 thread merge 与 Flutter 3.27 Android 默认范围。
- Android 17 [`TextureView.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/core/java/android/view/TextureView.java)、[`SurfaceView.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/core/java/android/view/SurfaceView.java) 与 [`SurfaceFlinger.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/services/surfaceflinger/SurfaceFlinger.cpp)：核对宿主 target 与最终 layer。
- kernel `android17-6.18-2026-06_r6` 的 [`dma-buf.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/drivers/dma-buf/dma-buf.c)、[`sync_file.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/drivers/dma-buf/sync_file.c) 以及 [Linux dma-buf 文档](https://docs.kernel.org/6.18/driver-api/dma-buf.html)：核对固定 tag 下的 buffer / fence 语义。

## 10. 类型边界与常见误判

### 与标准 HWUI 的边界

Flutter framework 自己完成 widget、layout、paint 与 scene composition，root surface 通常由 Flutter Raster / GPU producer 生成；Android HWUI 只在 texture / image root、宿主 UI 或 PlatformView 中负责部分绘制。

### 与 SurfaceView / TextureView 的边界

Flutter root 可以由这两种 Android View 承载，但文章还需覆盖 engine frame、external texture 与 PlatformView。只按容器分析会漏掉 Dart / Raster 和插件 producer。

### 常见误判

| 误判 | 正确检查方式 |
|---|---|
| Flutter 固定有独立 UI、Raster、platform 三线程 | Flutter 3.29+ 默认合并 UI 与 platform，按实际 engine 确认 |
| Flutter 帧结束就是上屏 | 继续追 GPU fence、root / host queue、SF latch 与 present |
| `RenderMode.surface` 内容属于 host App Window buffer | 查独立 `FlutterSurfaceView` child layer |
| `RenderMode.texture` 只有一条队列 | 分开 producer SurfaceTexture 与 host window BufferQueue |
| external texture 更新等于 Flutter 已显示 | 还要等待 Raster 采样、root 提交与 display present |
| `AndroidView` 固定使用 Hybrid Composition | 核对 TLHC / VD / HC / HCPP 与运行时回退 |
| Android 14+ 自动启用 HCPP | 还需 Flutter 3.44+、opt-in 与 Vulkan，且当前仍实验性 |
| Android 15 自动把旧 Flutter App 切到 Impeller | renderer 由 App 携带的 Flutter engine 决定 |

## 总结

Flutter 的显示链路要按三个维度展开：root RenderMode 决定 Flutter 主画面落到独立 Surface 还是宿主窗口；external texture 增加插件 producer 与 Flutter 采样；PlatformView 策略决定原生 View 被转成 texture，还是作为 Android 对象参与多 layer 合成。

Perfetto 分析时先固定 Android 与 Flutter 双版本，再画 View / Surface / layer 对象树，随后对齐 platform / Dart work、Raster、GPU completion、external texture、root 提交、SF latch 和 display present。这样才能把 Flutter framework 慢、插件 producer 慢、宿主消费慢与系统合成慢分开。

GENERATED FILE - DO NOT EDIT.
Source: docs/rendering_pipelines/S11_camera_type.md
Source SHA-256: 9b2a89db6cedcca193c8f0a2267dd448ee52be4c8728ac05e77f7d110aa2460e

# Android Perfetto 系列 - App 出图类型 - Camera 类型

Camera 页面的主体像素由 sensor、ISP 与 Camera HAL 生产，宿主 UI 只配置输出目标、控制拍摄并承载预览。预览、录像、分析和拍照可以来自同一组 capture request，却拥有不同 buffer pool、consumer 和返回节奏；任一 consumer 长时间占用 buffer，都可能反压整个 session。

本文以 Android 17 / API 37、`android-17.0.0_r1` 为平台源码锚点，kernel 侧以 `android17-6.18-2026-06_r6` 为锚点。CameraX、vendor tag、HAL / ISP 与厂商 SDK 另按设备版本核对。

<!--more-->

## 阅读导航

### 本文目录

- 1. HAL3 request-result 与多输出
- 2. SurfaceView、TextureView 与自研预览
- 3. 三组 fence 与 consumer backpressure
- 4. Perfetto 证据链
- 5. HAL、kernel 与内存证据
- 6. Android 12—17 版本演进
- 7. Android 17 源码入口
- 8. 类型边界与常见误判
- 总结

### 系列文章目录

1. [Android Perfetto 系列 - App 出图类型 - 总览与识别方法](S01_rendering_types_overview.md)
2. [Android Perfetto 系列 - App 出图类型 - AOSP 标准类型](S02_aosp_standard_type.md)
3. [Android Perfetto 系列 - App 出图类型 - SurfaceView 类型](S03_surfaceview_type.md)
4. [Android Perfetto 系列 - App 出图类型 - TextureView 类型](S04_textureview_type.md)
5. [Android Perfetto 系列 - App 出图类型 - 混合出图类型](S05_mixed_rendering_type.md)
6. [Android Perfetto 系列 - App 出图类型 - 多窗口类型](S06_multi_window_type.md)
7. [Android Perfetto 系列 - App 出图类型 - Software / 离屏类型](S07_software_offscreen_type.md)
8. [Android Perfetto 系列 - App 出图类型 - Native Graphics 类型](S08_native_graphics_type.md)
9. [Android Perfetto 系列 - App 出图类型 - WebView 类型](S09_webview_type.md)
10. [Android Perfetto 系列 - App 出图类型 - Flutter 类型](S10_flutter_type.md)
11. [Android Perfetto 系列 - App 出图类型 - Camera 类型](S11_camera_type.md)
12. [Android Perfetto 系列 - App 出图类型 - Video Overlay / HWC 类型](S12_video_overlay_hwc_type.md)
13. [Android Perfetto 系列 - App 出图类型 - Game 类型](S13_game_type.md)
14. [Android Perfetto 系列 - App 出图类型 - React Native 类型](S14_react_native_type.md)

## 1. HAL3 request-result 与多输出

Camera2 App 创建 `CameraCaptureSession` 时，把 preview、record、analysis、still capture 等 `Surface` 交给 camera service。`setRepeatingRequest()` 建立持续 request 流；framework `Camera3Device` / RequestThread 把 request、settings 和 output buffer 交给 HAL，HAL 驱动 sensor / ISP，并通过 `processCaptureResult()` 异步返回 metadata 与 buffer。

```mermaid
flowchart TD
    App["Camera2 / CameraX<br/>session outputs + repeating request"]
    Service["cameraserver<br/>Camera3Device / RequestThread"]
    HAL["Camera HAL3<br/>request queue + output buffers"]
    Sensor["sensor + ISP + vendor pipeline"]
    Result["partial / final metadata<br/>+ completed output buffers"]
    Preview["preview output buffer<br/>release fence from HAL"]
    Other["non-display outputs<br/>record → MediaCodec<br/>analysis → ImageReader<br/>capture → JPEG / HEIC / RAW"]
    SV["SurfaceView preview<br/>independent child layer"]
    TV["TextureView preview<br/>SurfaceTexture → host HWUI"]
    AppGPU["custom GL / Vulkan preview<br/>second producer"]
    Host["host App Window"]
    Output["custom renderer output Surface"]
    SF["SurfaceFlinger<br/>snapshot + composition"]
    Display["Composer HAL / display driver<br/>present feedback"]

    App -->|capture request + output buffers| Service --> HAL --> Sensor --> Result
    Result -->|capture result| Service
    Result --> Preview
    Result --> Other
    Preview --> SV --> SF
    Preview --> TV --> Host --> SF
    Preview --> AppGPU --> Output --> SF
    SF --> Display
    SV -. layer release fence .-> HAL
    TV -. buffer release .-> HAL
    AppGPU -. input buffer release .-> HAL
    Other -. encoder release / Image close .-> HAL
```

同一个 frame number 的 partial metadata、final metadata 和各 output buffer 可以分开返回。preview ready 不代表 analysis ready，capture callback 到达也不代表预览已 present。需要用 frame number、sensor timestamp、request id、buffer id 和 capture result 对齐。

`OutputConfiguration#setStreamUseCase()` 只是向 HAL 表达 preview、video record、still capture 等意图，帮助设备选择 sensor mode、ISP tuning 与 pipeline；它不创建额外同步，也不保证某路一定更快。支持集合必须从 camera characteristics 查询。

CameraX 在 Camera2 之上管理生命周期、use case binding、resolution negotiation 与 surface request。`PreviewView` 的 implementation mode、设备兼容性和变换需求会影响最终使用 SurfaceView 还是 TextureView。排障时同时记录 CameraX 版本和实际 target Surface。

## 2. SurfaceView、TextureView 与自研预览

### SurfaceView preview

HAL 把 preview buffer 直接 queue 到独立 Surface。SurfaceFlinger 看到 preview child layer 与宿主 App Window 两个对象：preview layer 承载相机像素，host window 承载快门、对焦框和遮罩。SF 在同一 display 周期选择可用 snapshot，HWC 再决定 preview 是否能用 DEVICE composition。

独立 layer 避免宿主每帧采样预览纹理，适合高分辨率持续预览。几何、crop、rotation、alpha、圆角和 lifecycle 仍由宿主 transaction 协调；preview buffer 早到而几何晚到，同样会出现错位或沿用旧状态。

### TextureView preview

HAL 先写 `SurfaceTexture`，宿主 HWUI 在窗口 draw 中 acquire 最新 camera buffer，并作为 texture 采样进 App Window。这里有两条 BufferQueue：camera → SurfaceTexture，以及 host HWUI → App Window。相机帧 ready 以后还要等宿主 `Choreographer`、traversal、RenderThread 与 host queue。

TextureView 便于 matrix、clip、alpha 和 View hierarchy 动画，但会增加一次宿主 GPU 采样与带宽。SF 最终通常只看到 host window，不能用 layer tree 直接判断 camera producer 是否晚。

### GL / Vulkan 自研预览

滤镜、畸变矫正、分割或 AR 常让 camera buffer 先进入 external OES texture、`AHardwareBuffer` 或 `ImageReader`，经 App GPU pass 后再输出到可见 Surface。此时 HAL 是第一生产者，自研 renderer 是中间 consumer 与第二生产者。要分别量 camera fence、GPU 处理和最终 surface present。

## 3. 三组 fence 与 consumer backpressure

HAL3 buffer 流转至少涉及三类同步。

| 同步对象 | 含义 | 常见等待方 |
|---|---|---|
| framework acquire fence 交给 HAL | output buffer 何时可供 HAL 写入 | HAL / ISP |
| HAL release fence 随 result 返回 | HAL 何时完成写入，consumer 可以读取 | BufferQueue、ImageReader、codec、App GPU |
| SF / HWC layer release fence | display consumer 不再读取 preview buffer | preview producer / BufferQueue |

display present fence 只描述一轮 display frame 的 present 边界，不能替代 camera frame completion。analysis / capture buffer 不上屏时也没有 display present fence。

`ImageReader.acquireLatestImage()` 可以丢弃旧分析帧，适合只关心最新结果；`acquireNextImage()` 保留顺序，consumer 处理跟不上时更容易耗尽 `maxImages`。无论使用哪一个，`Image.close()` / `ImageProxy.close()` 都是归还 buffer 的关键动作。录像 encoder 不及时消费、still capture 持有 Image 过久，也可能让 HAL 缺少 output buffer。

多路 session 的 stall 不一定同时发生。HAL 可以先返回 preview，稍后等待 analysis；也有设备 pipeline 会因共享 ISP stage 或有限 buffer pool 让慢 consumer 拖住后续 request。必须以实际 request-result 和 buffer 状态确认。

## 4. Perfetto 证据链

第一步记录 camera id、physical / logical camera、session outputs、format、size、fps range、dynamic range profile、stream use case、CameraX 版本和预览 carrier。

第二步找出 App camera thread、binder callback、`cameraserver`、Camera3 RequestThread、vendor HAL 线程、ImageReader / codec consumer 和最终 preview layer。线程名受厂商影响，request id、frame number 和调用栈更可靠。

| 现象 | 可能瓶颈 | 验证证据 |
|---|---|---|
| request 提交间隔异常 | App / CameraX 控制、session 重配、cameraserver 排队 | repeating request、binder、RequestThread |
| sensor timestamp 间隔异常 | sensor / HAL / ISP、曝光或帧率切换 | result metadata、vendor event、SOF |
| HAL 结果晚 | ISP、vendor algorithm、output buffer 不足 | process request/result、fence、buffer 状态 |
| analysis 越来越晚 | consumer 慢或 Image 未关闭 | acquire / close、`maxImages`、queue depth |
| SurfaceView preview 已 queue 但没换帧 | acquire fence、SF latch 或 HWC | preview layer、FrameTimeline、composition |
| TextureView buffer 已到但屏幕晚 | host traversal / texture acquire / GPU | SurfaceTexture、host main / RT、host layer |

复原单帧时按 request → sensor timestamp → HAL result → preview queue → SF latch → display present 排列。多路输出各自保留 result 时间，避免用 analysis callback 代替 preview ready。

## 5. HAL、kernel 与内存证据

AOSP 只能固定 framework 与 camera service 边界，vendor HAL、ISP firmware、sensor driver 和算法库需要设备证据。可用信息包括 camera service event log、HAL dump、vendor trace、V4L2 / media controller event、SOF / EOF、ISP job、IOMMU fault 和频率 / 带宽轨道。

`android17-6.18-2026-06_r6` 下，camera GraphicBuffer 通常借助 dma-buf 跨 HAL、GPU、codec 和 HWC 共享，dma-fence / sync_file 传递异步完成关系。内存压力还要看 dma-buf 总量、CMA / page allocation、IOMMU map、page fault、direct reclaim、PSI memory 与内存带宽。Android common kernel 不规定厂商 camera driver 必须暴露同一组 tracepoint。

## 6. Android 12—17 版本演进

### Android 12 / API 31

Camera2 vendor extensions 正式进入平台，Bokeh、HDR、Night 等能力可通过 `CameraExtensionSession` 查询和使用；maximum-resolution stream 配置也为 Quad / Nona Bayer 传感器提供公开边界。HAL3 多输出与 Surface 预览主线保持稳定。

### Android 13 / API 33

Camera2 增加 10-bit HDR video capture 与 DynamicRangeProfiles，preview 和 record 需要协商兼容 profile、format 与 surface 组合。stream use case 进入公开配置，帮助 HAL 按预览、录像、拍照等意图优化 pipeline。它们扩大了配置空间，也增加 session 组合验证的重要性。

### Android 14 / API 34

Android 14 引入 Ultra HDR still image 并增强 camera extensions。Gainmap 图像保存与显示属于拍照结果链路，不应写成 preview 必然变成 HDR。标准 request-result、ImageReader 回收和预览承载拓扑没有结构性变化。

### Android 15 / API 35

Low Light Boost 成为 Camera2 与 night extension 可查询的连续预览 AE mode，可在暗光下增强 preview / video；它与多帧合成的 Night still capture 机制不同。更长曝光和算法负载可能改变帧间隔，分析时结合 result metadata。

### Android 16 / API 36

Camera2 新增更精细的 color temperature / tint、hybrid auto-exposure、night mode indicator 与 motion photo capture intent 等能力。它们改变控制和 metadata，不替代 output Surface、HAL buffer 与 consumer 回收主线。

### Android 17 / API 37

Android 17 新增 `ImageFormat.RAW14`，兼容传感器可输出 14-bit RAW。RAW14 会提高单帧数据量和内存 / 存储压力，但普通 preview 不会自动改为 RAW14。平台源码按 `android-17.0.0_r1` 的 Camera3、BufferQueue 与 SF FrontEnd 分析，vendor pipeline 仍需设备版本锚点。

## 7. Android 17 源码入口

- [`CameraDeviceImpl.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/core/java/android/hardware/camera2/impl/CameraDeviceImpl.java) 与 [`CameraCaptureSessionImpl.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/core/java/android/hardware/camera2/impl/CameraCaptureSessionImpl.java)：Camera2 session 与 callback。
- [`Camera3Device.cpp`](https://android.googlesource.com/platform/frameworks/av/+/android-17.0.0_r1/services/camera/libcameraservice/device3/Camera3Device.cpp)、[`Camera3Stream.cpp`](https://android.googlesource.com/platform/frameworks/av/+/android-17.0.0_r1/services/camera/libcameraservice/device3/Camera3Stream.cpp)：request、stream 与 buffer 状态。
- [Camera HAL3 request / result](https://source.android.com/docs/core/camera/camera3_requests_hal) 与 [Camera2 multiple streams](https://developer.android.com/media/camera/camera2/multiple-camera-streams-simultaneously)：核对多输出语义。
- [CameraX Preview](https://developer.android.com/media/camera/camerax/preview)、[Image analysis](https://developer.android.com/media/camera/camerax/analyze) 与 [`ImageReader`](https://developer.android.com/reference/android/media/ImageReader)：核对 carrier 和 backpressure。
- [`SurfaceFlinger.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/services/surfaceflinger/SurfaceFlinger.cpp) 与 [`HWComposer.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/services/surfaceflinger/DisplayHardware/HWComposer.cpp)：预览最终显示。
- [Android 17 release notes](https://developer.android.com/about/versions/17/release-notes)、kernel `android17-6.18-2026-06_r6` 的 [`dma-buf.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/drivers/dma-buf/dma-buf.c) 与 [`sync_file.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/drivers/dma-buf/sync_file.c)：核对 RAW14 与固定 kernel tag 的同步边界。

## 8. 类型边界与常见误判

SurfaceView / TextureView 描述预览承载，Camera 描述 HAL producer 与多输出。自研 GL 预览同时具有 Camera 输入和 Native Graphics 输出，两个阶段都要分析。

| 误判 | 正确检查方式 |
|---|---|
| 宿主 `doFrame` 正常，camera preview 就正常 | 继续查 HAL result、preview buffer 与 carrier |
| preview 正常，analysis / record 也正常 | 按每个 output 的 buffer 和 consumer 分别验证 |
| capture callback 到达就是照片完整可用 | 区分 metadata、buffer ready 与 Image close |
| `Image.close()` 只影响内存 | 它决定 buffer 是否回池，可能反压后续 request |
| SurfaceView 预览一定走 HWC overlay | 查实际 composition type 与整组 layer 条件 |
| Low Light Boost 等于 Night still capture | 前者是连续预览 AE mode，后者通常是多帧静态合成 |
| RAW14 会改变所有 Android 17 预览 | 仅支持并显式配置的 RAW capture stream 使用 |

## 总结

Camera trace 要从 session outputs 和 HAL3 request-result 开始，再沿 preview、record、analysis、capture 四类 consumer 追踪 buffer 回收。SurfaceView 预览形成独立 layer，TextureView 预览还要经过宿主 HWUI，自研 renderer 则增加第二生产者。

把 request、sensor timestamp、HAL result、consumer release、preview latch 和 display present 串起来，才能区分 sensor / ISP 慢、output buffer 不足、analysis 或 encoder 回压、宿主消费晚与 SF / HWC 显示晚。

GENERATED FILE - DO NOT EDIT.
Source: docs/rendering_pipelines/S12_video_overlay_hwc_type.md
Source SHA-256: d7791d38863dbddf3dd9ca7242ed0f78c5febe53b4c899ce8568dd4b38447e6a

# Android Perfetto 系列 - App 出图类型 - Video Overlay / HWC 类型

视频是否走 overlay 不是播放器创建 `SurfaceView` 时就确定的。播放器和 codec 负责按媒体时钟提交视频帧，SurfaceFlinger 每个显示周期把完整 layer 集合交给 HWC，HWC 再根据格式、缩放、旋转、HDR、protected usage、plane 数量与带宽选择 DEVICE、CLIENT 或 SIDEBAND 等 composition type。

本文以 Android 17 / API 37、`android-17.0.0_r1` 为平台源码锚点，kernel 侧以 `android17-6.18-2026-06_r6` 为锚点。播放器、Codec2 / OMX 组件、DRM、codec HAL、display HAL 与厂商驱动另按设备版本核对。

<!--more-->

## 阅读导航

### 本文目录

- 1. 普通 Surface 视频输出
- 2. SurfaceView 与 TextureView 的显示差异
- 3. Tunneled Playback 与 sideband
- 4. Protected content 与安全显示
- 5. HWC composition、时间戳与刷新率
- 6. Perfetto 证据链
- 7. Kernel / driver 证据
- 8. Android 12—17 版本演进
- 9. Android 17 源码入口
- 10. 类型边界与常见误判
- 总结

### 系列文章目录

1. [Android Perfetto 系列 - App 出图类型 - 总览与识别方法](S01_rendering_types_overview.md)
2. [Android Perfetto 系列 - App 出图类型 - AOSP 标准类型](S02_aosp_standard_type.md)
3. [Android Perfetto 系列 - App 出图类型 - SurfaceView 类型](S03_surfaceview_type.md)
4. [Android Perfetto 系列 - App 出图类型 - TextureView 类型](S04_textureview_type.md)
5. [Android Perfetto 系列 - App 出图类型 - 混合出图类型](S05_mixed_rendering_type.md)
6. [Android Perfetto 系列 - App 出图类型 - 多窗口类型](S06_multi_window_type.md)
7. [Android Perfetto 系列 - App 出图类型 - Software / 离屏类型](S07_software_offscreen_type.md)
8. [Android Perfetto 系列 - App 出图类型 - Native Graphics 类型](S08_native_graphics_type.md)
9. [Android Perfetto 系列 - App 出图类型 - WebView 类型](S09_webview_type.md)
10. [Android Perfetto 系列 - App 出图类型 - Flutter 类型](S10_flutter_type.md)
11. [Android Perfetto 系列 - App 出图类型 - Camera 类型](S11_camera_type.md)
12. [Android Perfetto 系列 - App 出图类型 - Video Overlay / HWC 类型](S12_video_overlay_hwc_type.md)
13. [Android Perfetto 系列 - App 出图类型 - Game 类型](S13_game_type.md)
14. [Android Perfetto 系列 - App 出图类型 - React Native 类型](S14_react_native_type.md)

## 1. 普通 Surface 视频输出

常规播放从压缩码流、媒体时钟和解码器开始。播放器把输出 `Surface` 传给 `MediaCodec.configure()`；Codec2 或旧 OMX 组件解码后，播放器调用 `releaseOutputBuffer(index, render)` 或带纳秒时间戳的 overload，把对应 output buffer 送往 Surface。

```mermaid
sequenceDiagram
    participant Player as Player / MediaClock
    participant Codec as MediaCodec / Codec2 or OMX
    participant BQ as Surface / BufferQueue
    participant Host as TextureView / host HWUI
    participant SF as SF FrontEnd / CompositionEngine
    participant HWC as Composer HAL / RenderEngine
    participant DD as Display driver

    Player->>Codec: compressed samples + presentation time
    Codec->>Codec: decode into graphic buffer
    Player->>Codec: releaseOutputBuffer(renderTimestampNs)
    Codec->>BQ: queueBuffer(buffer, timestamp, fence)
    alt output is SurfaceView / independent Surface
        BQ->>SF: video layer buffer update + acquire fence
    else output is TextureView
        BQ->>Host: SurfaceTexture frame + acquire dependency
        Host->>Host: sample into host App Window buffer
        Host->>SF: host window buffer transaction
    end
    SF->>SF: choose ready buffer for expected present
    SF->>HWC: validate or presentOrValidate
    opt CLIENT composition required
        SF->>SF: RenderEngine creates client target
        SF->>HWC: setClientTarget
    end
    opt 当前轮尚未 present
        SF->>HWC: presentDisplay
    end
    HWC->>DD: submit display frame
    DD-->>SF: display present fence
    HWC-->>SF: layer release fences
```

`releaseOutputBuffer()` 返回只表示播放器已把 output buffer 交给 Surface 路径。Codec GPU / hardware 写入完成、BufferQueue queue、SF latch 和 display present 仍在后面。

带 `renderTimestampNs` 的提交会成为 buffer 的期望显示时间。Android 17 `BufferQueueProducer` 保存 requested present timestamp，consumer 在 `acquireBuffer(expectedPresent)` 中可能返回 `PRESENT_LATER`，避免过早取出未来帧。时间戳离系统单调时钟太远、播放器媒体时钟漂移或队列堆积，都会造成重复旧帧或丢弃晚帧。

普通视频输出仍有三类 fence：codec / producer 完成写入的 acquire fence，HWC / SF 不再使用 layer buffer 的 release fence，以及一轮 display frame 的 present fence。present fence 属于 display，不属于某一块视频 buffer。

## 2. SurfaceView 与 TextureView 的显示差异

### SurfaceView：独立视频 layer

视频直接输出到 `SurfaceView` 时，buffer 进入独立 child Surface。宿主 App Window 负责播放器控件、字幕、弹幕和遮罩；视频 layer 拥有自己的 buffer update、fence 与 composition type。

YUV buffer 若满足设备 plane 的格式、缩放、旋转、色彩、protected 与带宽条件，HWC 可以选择 DEVICE composition，避免 RenderEngine 再做一次全屏采样。这个结果每帧都可能变化：弹窗、系统栏、圆角遮罩、其他视频、HDR / SDR 混合和 plane 竞争都可能让它回到 CLIENT composition。

### TextureView：先采样进宿主窗口

视频输出到 `SurfaceTexture` 后，宿主 HWUI acquire 最新 image，把它采样进 App Window buffer。SurfaceFlinger 通常只看到 host window，视频已失去独立 layer 的直接 HWC plane 选择机会。

TextureView 便于 View matrix、clip、alpha 与动画，却增加一条 producer BufferQueue、宿主 texture acquire、GPU 采样和 host BufferQueue。codec 按时提交以后，宿主主线程或 RenderThread 迟到仍会让视频晚一帧。

### 自研 GL / Vulkan 视频处理

滤镜、超分、色彩转换或字幕烧录会让解码 buffer 先进入 App GPU，再输出到新的可见 Surface。此时 codec 是第一生产者，App renderer 是第二生产者。输入 fence、GPU pass、输出 fence 和最终 composition 都要量，不能只看 `MediaCodec`。

## 3. Tunneled Playback 与 sideband

Tunneled Playback 把视频解码、音频时钟和显示硬件放到更直接的硬件同步路径。应用先查询 `FEATURE_TunneledPlayback`，配置 audio session id；支持的 codec / HAL 建立 sideband stream，并通过 native window sideband handle 交给 SurfaceFlinger / HWC。

```mermaid
flowchart TD
    Player["player + audio session<br/>media PTS"]
    DRM["optional DRM / secure session<br/>protected output requirement"]
    Codec["tunneled codec / HAL"]
    AVSync["hardware A/V sync"]
    Sideband["sideband stream handle"]
    SF["SurfaceFlinger sideband layer"]
    HWC["Composer SIDEBAND / vendor path"]
    Driver["secure display / display driver"]
    Display["display present feedback"]

    Player --> Codec --> AVSync --> Sideband --> SF --> HWC --> Driver --> Display
    DRM -. secure configuration .-> Codec
    DRM -. protected path .-> HWC
```

sideband layer 不以普通非 tunneled 视频的逐帧 `queueBuffer()` 形态出现。App trace 中可能没有对应的 `BufferTX`、buffer id 和 release 节奏，帧选择与 A/V sync 主要在 codec HAL、audio / AV sync、HWC 和 driver 中完成。

Android 17 旧 OMX 路径的 `ACodec` 会为 tunneled video 配置 video tunnel mode，并调用 `native_window_set_sideband_stream()`。设备也可以通过 Codec2 与厂商组件实现同类能力。API capability 只说明可请求，实际建立、稳定播放和时间戳质量仍需日志与 HAL 证据。

## 4. Protected content 与安全显示

DRM 内容可能要求 secure decoder、protected graphic buffer、secure Surface 和受保护的 HWC / display path。保护要求由 DRM session、codec capability、buffer usage 与设备认证共同决定。

protected layer 不等于普通 overlay 的同义词。设备可能用安全硬件 plane，也可能使用受保护图形上下文的安全合成路径；任何不安全的 readback、截图或普通 GPU 上下文都必须被拒绝。黑屏、绿屏或 `MediaCodec` 配置失败时，先核对 secure decoder、Surface security、HDCP / external display 与 protected composition 能力。

安全内容经常无法被常规 screenshot、screen recording 或 GPU capture 工具读取。Perfetto 仍可观察线程、transaction、fence 和 composition metadata，但像素不可见属于安全设计，不能当成 trace 缺失。

## 5. HWC composition、时间戳与刷新率

Android 17 Composer3 的 `Composition` 包含 CLIENT、DEVICE、SOLID_COLOR、CURSOR、SIDEBAND 等类型。SurfaceFlinger 先准备 layer 状态，再由 `HWComposer::getDeviceCompositionChanges()` 触发 validate / presentOrValidate 协商。HWC 返回 changed composition types 后，SF 接受调整；需要 CLIENT 时，RenderEngine 生成 client target 并交给 HWC。

`presentOrValidate` 返回 PresentSucceeded 时，本轮已经执行 present。后续流程只收集对应结果，不能再描述成“随后固定调用第二次 present”。常规 validate 分支完成状态调整后才进入 present。

视频 cadence 与 display refresh rate 要分开。24 fps 内容可以在 120 Hz display 上用 5:5 cadence 稳定显示，也可以请求切换到兼容模式。`Surface#setFrameRate()` / `ANativeWindow_setFrameRate()` 提供内容帧率提示，系统还会综合其他 layer、触摸、功耗和显示模式；调用成功不保证立刻切换刷新率。

刷新率切换、VRR / ARR 解决 display cadence 与功耗，无法修复 decoder 晚、timestamp 错、queue-stuffing 或 acquire fence 晚。Perfetto 中应同时看 requested frame rate、active mode、vsync period、buffer timestamp、latch 和 present。

## 6. Perfetto 证据链

第一步记录内容 codec、分辨率、帧率、HDR profile、DRM / secure、tunneled 状态、输出 Surface 类型、播放器版本和 display mode。

第二步在 layer tree 中确认视频主体。SurfaceView 通常有独立 video layer；TextureView 只剩 host App Window；tunneled path 表现为 sideband layer。layer name 只是线索，owner、parent、buffer format、composition type 和 sideband 状态更可靠。

| 现象 | 可能瓶颈 | 验证证据 |
|---|---|---|
| decoder output 晚 | 码流、codec、硬件负载、DRM | input / output PTS、codec callback、HAL event |
| output 已 release 但 buffer 晚 | codec fence、Surface queue、timestamp | queueBuffer、acquire fence、requested present |
| video layer ready 但未更新 | SF 选择未来帧、acquire fence、layer 状态 | acquireBuffer、latch、FrameTimeline |
| DEVICE 频繁切 CLIENT | plane 竞争、变换、alpha、HDR、系统 overlay | composition type、RenderEngine、layer 状态 |
| 视频流畅但控件卡 | host App Window 或主线程晚 | host `doFrame`、RenderThread、host layer |
| tunneled 只有音频或黑屏 | tunnel 建立、sideband、secure / HDCP | codec config、sideband handle、HWC / DRM log |

普通路径按 compressed sample → codec output → release timestamp → queueBuffer → SF latch → HWC present 复原单帧。Tunneled path 改用 PTS、audio clock、codec / HAL 与 sideband / HWC 事件关联，不能强找不存在的逐帧 BufferQueue 证据。

## 7. Kernel / driver 证据

`android17-6.18-2026-06_r6` 下，非 tunneled graphic buffer 通常通过 dma-buf 跨 codec、GPU、SF 与 HWC 共享，dma-fence / sync_file 传递异步完成关系。补看 codec job、GPU / display frequency、DRM / KMS 或厂商 display trace、IOMMU、内存带宽和 fence wait。

Android 设备未必使用主线 DRM / KMS 显示栈，很多 SoC 保留厂商驱动与私有 tracepoint。kernel 锚点固定公共同步语义，具体 plane 分配、带宽投票、secure path 和 scanout 时序仍以设备驱动为准。

## 8. Android 12—17 版本演进

### Android 12 / API 31

Android 12 改善 `setFrameRate()` 的刷新率切换，应用可允许非无缝 mode switch。普通 Surface video、tunneled sideband 与 protected playback 主线已经成熟；BLAST / FrameTimeline 成为现代显示诊断背景。

### Android 13 / API 33

HWC HAL 从这一版起以 AIDL 定义。SurfaceFlinger 新增 AutoSingleLayer，可在单 layer 简单 buffer update 时允许特定 unsignaled latching；包含 geometry 或 sync transaction 的多 layer 场景不适用。Choreographer / SurfaceControl 公开更多 frame timeline 信息，播放器仍需正确提交时间戳。

### Android 14 / API 34

普通 codec → Surface → SF / HWC 拓扑保持稳定。平台增加扩展亮度 / HDR 相关控制，但 HDR 视频仍需从 codec capability、MediaFormat、dataspace 与 display 能力逐项协商。Android 14 版本号不能保证某种 HDR 或 tunneled 组合可用。

### Android 15 / API 35

Android 15 提供 `setDesiredHdrHeadroom()`，混合 HDR 视频与 SDR UI 时可表达期望亮度范围；系统仍可能按面板与全局内容调整。ARR 在支持硬件上进入平台，用离散 Vsync 步进适应内容帧率。

### Android 16 / API 36

Android 16 增加 ARR capability / suggested frame rate API、APV codec 支持，以及 TV 侧 `MediaQuality` picture / audio profile。APV 面向高质量录制和后期场景，不能据此推断所有播放设备有硬件 APV overlay。

### Android 17 / API 37

Android 17 增加 VVC / H.266 平台支持，并改进 encoder temporal layering capability 反馈。它们改变 codec 能力与编码配置，常规解码 Surface、sideband、SF FrontEnd、CompositionEngine 与 AIDL Composer 主线保持稳定。源码统一到 `android-17.0.0_r1`，设备能力仍需运行时查询。

## 9. Android 17 源码入口

- [`MediaCodec.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/media/java/android/media/MediaCodec.java) 与 [`MediaFormat.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/media/java/android/media/MediaFormat.java)：输出 Surface、render timestamp、tunneled 配置。
- [`CCodecBufferChannel.cpp`](https://android.googlesource.com/platform/frameworks/av/+/android-17.0.0_r1/media/codec2/sfplugin/CCodecBufferChannel.cpp) 与 [`ACodec.cpp`](https://android.googlesource.com/platform/frameworks/av/+/android-17.0.0_r1/media/libstagefright/ACodec.cpp)：Codec2 普通 Surface 输出与旧 OMX tunneled sideband。
- [`BufferQueueProducer.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/libs/gui/BufferQueueProducer.cpp) 与 [`BufferQueueConsumer.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/libs/gui/BufferQueueConsumer.cpp)：时间戳、queue 与 expected present 选择。
- [`Composition.aidl`](https://android.googlesource.com/platform/hardware/interfaces/+/android-17.0.0_r1/graphics/composer/aidl/android/hardware/graphics/composer3/Composition.aidl)、[`Display.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/services/surfaceflinger/CompositionEngine/src/Display.cpp) 与 [`HWComposer.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/services/surfaceflinger/DisplayHardware/HWComposer.cpp)：composition type、validate 与 present。
- [Frame rate guide](https://developer.android.com/media/optimize/performance/frame-rate)、[Multimedia tunneling](https://source.android.com/docs/devices/tv/multimedia-tunneling) 与 [Android 17 release notes](https://developer.android.com/about/versions/17/release-notes)：公开节拍、sideband 与版本边界。
- kernel `android17-6.18-2026-06_r6` 的 [`dma-buf.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/drivers/dma-buf/dma-buf.c)、[`sync_file.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/drivers/dma-buf/sync_file.c) 与 [`dma-fence.h`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/include/linux/dma-fence.h)：固定 kernel tag 下的共享 buffer 与 fence 语义。

## 10. 类型边界与常见误判

SurfaceView 描述视频承载对象，Video Overlay / HWC 关注 codec 时间戳、sideband、protected path 与最终 composition。Camera 也可能获得 DEVICE composition，但 producer 来自 sensor / ISP，节拍由 capture request 驱动。

| 误判 | 正确检查方式 |
|---|---|
| 使用 SurfaceView 就固定走 overlay | 查看每帧实际 composition type 与 plane 条件 |
| `releaseOutputBuffer()` 返回就已显示 | 继续追 queue、latch、HWC 和 present |
| DEVICE composition 表示 decode 零成本 | 它只省去 SF GPU 合成，解码成本仍在 codec 侧 |
| TextureView 视频仍能独立分配 HWC plane | 视频已采样进 host window，HWC 看到宿主 buffer |
| tunneled playback 也有普通逐帧 BufferTX | 检查 sideband layer、audio clock 与 HAL / HWC |
| protected content 一定走普通 overlay | 核对 secure decoder、protected buffer 与安全合成能力 |
| 切换到 120 Hz 就能修复 24 fps 卡顿 | 同时检查 PTS、cadence、decoder 与队列节拍 |

## 总结

普通视频路径从 MediaCodec output、render timestamp 和 Surface queue 进入 SurfaceFlinger；SurfaceView 保留独立视频 layer，TextureView 把视频合入宿主窗口。Tunneled Playback 改用 sideband 与硬件 A/V 同步，protected content 还要满足安全显示要求。

Perfetto 分析要把 codec 输出、buffer timestamp、acquire fence、SF 选择、composition type、display mode 和 present 放在同一条时间线上。这样才能区分解码晚、播放器时间戳错误、BufferQueue 堆积、HWC 策略变化、刷新率 cadence 与 display driver 问题。

GENERATED FILE - DO NOT EDIT.
Source: docs/rendering_pipelines/S13_game_type.md
Source SHA-256: febe59cdcbfc9f84b238e4f2ea104001c70a1ec9f4aed057f2da5fb9e6ee44b0

# Android Perfetto 系列 - App 出图类型 - Game 类型

本地游戏通常由自有 game loop、render / RHI thread 和 GPU swapchain 生产画面。分析重点是触控到显示的整段延迟：输入在哪一帧采样，逻辑和渲染何时完成，GPU 何时写完 buffer，队列里压了几帧，SurfaceFlinger 最终显示哪一帧。

本文以 Android 17 / API 37、`android-17.0.0_r1` 为平台源码锚点，kernel 侧以 `android17-6.18-2026-06_r6` 为锚点。Unity、Unreal、Cocos、自研引擎、Swappy 与 XR 运行时都有独立版本，报告中要记录引擎版本、graphics API、render pipeline 与 frame pacing 配置。

<!--more-->

## 阅读导航

### 本文目录

- 1. 本地游戏一帧的完整路径
- 2. Frame pacing、queue-stuffing 与输入延迟
- 3. CPU、GPU 与显示端怎么分责
- 4. ADPF、Game Mode 与持续性能
- 5. 小游戏、云游戏、AR 与 XR 的边界
- 6. Perfetto 证据链
- 7. Android 12—17 版本演进
- 8. Android 17 源码入口
- 9. 常见误判
- 总结

### 系列文章目录

1. [Android Perfetto 系列 - App 出图类型 - 总览与识别方法](S01_rendering_types_overview.md)
2. [Android Perfetto 系列 - App 出图类型 - AOSP 标准类型](S02_aosp_standard_type.md)
3. [Android Perfetto 系列 - App 出图类型 - SurfaceView 类型](S03_surfaceview_type.md)
4. [Android Perfetto 系列 - App 出图类型 - TextureView 类型](S04_textureview_type.md)
5. [Android Perfetto 系列 - App 出图类型 - 混合出图类型](S05_mixed_rendering_type.md)
6. [Android Perfetto 系列 - App 出图类型 - 多窗口类型](S06_multi_window_type.md)
7. [Android Perfetto 系列 - App 出图类型 - Software / 离屏类型](S07_software_offscreen_type.md)
8. [Android Perfetto 系列 - App 出图类型 - Native Graphics 类型](S08_native_graphics_type.md)
9. [Android Perfetto 系列 - App 出图类型 - WebView 类型](S09_webview_type.md)
10. [Android Perfetto 系列 - App 出图类型 - Flutter 类型](S10_flutter_type.md)
11. [Android Perfetto 系列 - App 出图类型 - Camera 类型](S11_camera_type.md)
12. [Android Perfetto 系列 - App 出图类型 - Video Overlay / HWC 类型](S12_video_overlay_hwc_type.md)
13. [Android Perfetto 系列 - App 出图类型 - Game 类型](S13_game_type.md)
14. [Android Perfetto 系列 - App 出图类型 - React Native 类型](S14_react_native_type.md)

## 1. 本地游戏一帧的完整路径

引擎线程名各不相同，职责通常可以归入五段：输入与逻辑、渲染准备、GPU 提交、swapchain present、Android 显示。

```mermaid
flowchart TD
    Input["InputReader / InputDispatcher<br/>game input sampling"]
    Logic["Game / Logic thread<br/>script + physics + animation"]
    Render["Render / RHI threads<br/>culling + draw list + command recording"]
    Pace["Swappy / engine frame pacing<br/>target present + in-flight control"]
    Submit["GLES or Vulkan driver<br/>GPU queue submit"]
    GPU["GPU execution<br/>producer completion fence"]
    Swap["eglSwapBuffers or vkQueuePresentKHR"]
    BQ["ANativeWindow / BufferQueue<br/>buffer + producer fence"]
    SF["SurfaceFlinger<br/>layer snapshot + latch"]
    HWC["HWC / RenderEngine composition"]
    Driver["Composer HAL / display driver"]
    Present["display present feedback"]

    Input --> Logic --> Render --> Pace --> Submit
    Submit --> GPU
    Submit --> Swap --> BQ
    GPU -->|producer completion fence| BQ
    BQ --> SF --> HWC --> Driver --> Present
    Present -. pacing feedback .-> Pace
    HWC -. per-layer release fence .-> BQ
```

Game / Logic thread 处理输入、脚本、物理和动画。Render / RHI thread 做可见性裁剪、draw list、resource transition 与 command buffer 录制。Vulkan 通过 `vkAcquireNextImageKHR()`、`vkQueueSubmit()`、`vkQueuePresentKHR()` 管理 swapchain；OpenGL ES 通过 EGL window surface 和 `eglSwapBuffers()` 交付 buffer。

CPU submit 返回以后，GPU 仍在异步执行。producer fence signal 才表示 SurfaceFlinger 可以读取这块 buffer；display present fence 表示整轮 display frame 已进入 present 边界；layer release fence 决定旧 swapchain image 何时可复用。这三个时间不能合成一个“渲染完成”。

游戏 Surface 最终仍是 Android layer。SF FrontEnd 选择本轮 snapshot，CompositionEngine 与 HWC 决定 DEVICE / CLIENT composition。游戏本身已占满 GPU 时，额外的 RenderEngine client composition 会与游戏争抢 GPU 和内存带宽。

## 2. Frame pacing、queue-stuffing 与输入延迟

游戏持续尽快 present 会填满 BufferQueue。队列满后，render thread 周期性卡在 acquire、swap 或 present，表面上获得了“自动限速”，代价是更多 in-flight frame。输入在更早的逻辑帧采样，用户看到结果时可能已多排一到两帧。

Swappy 是 AGDK Frame Pacing library。GLES 使用 `SwappyGL_swap()` 包装 `eglSwapBuffers()`；Vulkan 使用 `SwappyVk_queuePresent()` 代为调用 `vkQueuePresentKHR()`，并可能插入 presentation timestamp 与同步命令。它利用 Choreographer、`EGL_ANDROID_presentation_time` / `VK_GOOGLE_display_timing` 和 fence 控制 swap interval 与 pipeline mode。

Swappy 中的等待可以是主动 pacing。判断它是否合理，要一起看目标帧率、GPU 完成时间、pending buffer、相邻 present 间隔与输入到显示延迟。只把 wait slice 缩短，往往会重新制造 queue-stuffing。

Vulkan acquire / present 的阻塞行为取决于 driver、present mode 与 presentation engine 状态，不能充当业务线程同步器。GPU—GPU 使用 semaphore，GPU—CPU 使用 fence，resource hazard 使用 barrier / event。

触控到显示至少包含：InputReader 采样、InputDispatcher 分发、游戏读取输入、logic / simulation、render preparation、GPU execution、queue、SF latch、display present。游戏 FPS 正常时，任一段额外排队仍可能让操作发飘。

## 3. CPU、GPU 与显示端怎么分责

CPU bound 常见表现是 Game / Render thread 超过帧预算，GPU 队列出现空洞。原因可能是脚本、物理、animation、draw-call preparation、shader / pipeline 同步创建、资源上传、JNI、锁竞争或 Runnable 调度延迟。

GPU bound 常见表现是 CPU 提交较早，GPU job 持续占满，producer fence 晚。需要用 GPU stage / counter 区分 fragment、vertex、texture、带宽、overdraw、tile memory、同步 bubble 与频率限制。降低分辨率主要缓解像素和带宽成本，减少 draw call 主要缓解 CPU / driver 成本。

display bound 指游戏 buffer 已 ready，后续仍错过 latch 或 present。检查 requested present time、SF layer、FrameTimeline、composition type、刷新率切换、HWC validate 与 display driver。SF 正常沿用旧帧时，根因也可能是 producer 晚到，而非 SF 自身计算慢。

稳定帧率要看长时间运行。温度上升后 CPU / GPU 频率下降、内存带宽限频或 power HAL 策略变化，会把首分钟的 120 fps 变成十分钟后的 80—100 fps 波动。性能测试应记录设备温度、Game Mode、充电状态、亮度、网络与环境温度。

## 4. ADPF、Game Mode 与持续性能

Game Mode 允许应用读取 STANDARD、PERFORMANCE、BATTERY 等用户选择，并调整帧率、分辨率与画质。OEM 也可以配置 Game Mode interventions；Android 13 QPR 起的 FPS throttling intervention 可能在平台侧限制游戏帧率。trace 中出现稳定的 45 / 60 fps 上限时，要先核对 intervention，不能直接归因于 engine limiter。

ADPF Performance Hint Session 把一组长期线程与周期 target duration 告诉系统，并持续报告 actual work duration。它帮助 power HAL 做动态资源分配，不是锁定大核或固定频率的接口。线程列表、目标时间和每帧报告不准确，会降低提示效果。

Game State / loading mode 让系统区分加载和持续 gameplay。Android 13 的 `GAME_LOADING` 可以在加载期提供临时策略，Android 14 的 `GAME` power mode 为前台游戏提供持续策略入口。具体 boost、持续时间和 thermal 处理由 OEM Power HAL 决定。

质量调节应形成反馈控制：温度、CPU / GPU headroom、实际 frame time 与用户 Game Mode 共同决定分辨率、阴影、后处理、LOD 和目标 FPS。频繁来回切档会制造新的 shader、resource 和 frame-time 抖动，需要滞回与最短保持时间。

## 5. 小游戏、云游戏、AR 与 XR 的边界

小游戏容器多一层 JS / TS 运行时、Canvas / WebGL 翻译与宿主 bridge。最终可能使用独立 Surface，也可能回到 TextureView 或 WebView host window。分析顺序是 JS task、native bridge、GPU submit、最终 Surface；不能只套本地 C++ 引擎线程名。

云游戏本地端主要是网络 jitter buffer、MediaCodec 解码与视频 Surface。端到端延迟还包括输入上行、云端排队、渲染、编码和下行网络。Perfetto 只能完整覆盖本机输入、网络线程、解码和显示，云端段需要服务端 timestamp / telemetry。

手机 AR 在本地游戏 loop 前增加 Camera sensor timestamp、IMU、VIO / SLAM 与 pose prediction。present fence 只证明 Android 显示完成；运动到光子的评估还要把 sensor、pose 与 predicted display time 放进同一时钟域。

头显 XR / OpenXR 由 `xrWaitFrame()` 给出 predicted display time，App 向运行时 swapchain 提交图像，运行时 compositor 负责 reprojection / timewarp 和最终显示。某些设备不会把最终帧呈现为普通 Android App Surface，验收边界要改用运行时与 display driver 事件。

## 6. Perfetto 证据链

第一步记录引擎版本、graphics API、refresh rate、目标 FPS、Game Mode、Swappy / 自研 pacing、render scale、HDR、Surface 类型和最大 in-flight frame 数。

第二步找到 Input、Game / Logic、Render / RHI、worker、GPU submit 和最终 layer。再为连续帧标出 input sample、logic start/end、submit、GPU end、queue、latch、present 与 release。

| 现象 | 可能瓶颈 | 验证证据 |
|---|---|---|
| Game thread 晚 | script、physics、锁、Runnable 延迟 | 线程状态、task marker、CPU profile |
| Render / RHI 晚 | culling、draw call、command recording、driver | render marker、worker dependency、ioctl |
| submit 早但 GPU fence 晚 | GPU workload、带宽、thermal、queue backlog | GPU stage、counter、frequency、fence |
| acquire / swap 周期性变长 | queue-stuffing、release fence、pacing | pending buffer、Swappy、present interval |
| buffer ready 但 present 晚 | SF / HWC、CLIENT composition、display mode | layer、FrameTimeline、composition、present fence |
| FPS 稳定但输入延迟大 | in-flight frame 过多或输入采样太早 | input id、frame id、queue depth、present |

单帧偶发问题看依赖链，持续波动看频率、温度和 pacing。平均 FPS 会掩盖 1% low、长帧簇和输入延迟，至少同时统计 frame-time 分布与 present-to-present 间隔。

kernel `android17-6.18-2026-06_r6` 下，swapchain buffer 使用 dma-buf，GPU / HWC 同步使用 dma-fence / sync_file。vendor GPU scheduler、devfreq、thermal、IOMMU fault、memory reclaim 和 display driver tracepoint 需要按设备补充。

## 7. Android 12—17 版本演进

### Android 12 / API 31

Game Mode API 在部分 Android 12 设备提供 STANDARD、PERFORMANCE 与 BATTERY 选择；Performance Hint Manager 也在 API 31 公开。BLAST / FrameTimeline 和改进后的 `setFrameRate()` 构成现代游戏显示分析基线。

### Android 13 / API 33

Game Mode 与 interventions 覆盖 Android 13+ 设备，QPR 加入 FPS throttling intervention；`GAME_LOADING` power mode 为加载阶段提供信号。HWC 进入 AIDL，AutoSingleLayer 只覆盖单 layer 简单 buffer 更新，不能同步复杂游戏 overlay。

### Android 14 / API 34

ADPF 增加前台 `GAME` power mode，OEM Power HAL 可据此应用游戏策略。EGL / Vulkan swapchain、BufferQueue 与 SF 主线没有结构性更换，实际表现更多取决于 engine、driver 与设备策略。

### Android 15 / API 35

ARR 进入支持设备，Vulkan Profiles for Android 从 `VPA15_minimums` 建立年度 profile 线。16 KB page size 要求 engine 和所有 native plugin 满足 ELF / APK 对齐；旧预编译库可能直接加载失败。

### Android 16 / API 36

Android 16 提供 CPU / GPU headroom 和 ARR capability / suggested frame rate API。面向 target 36 的 GPU syscall filtering 不影响受支持的 GLES / Vulkan API，但非标准 ioctl、注入层和陈旧工具要验证。

### Android 17 / API 37

Android 17 支持 `VK_EXT_present_timing`，自研 Vulkan pacing 可以获得标准化 present stage 反馈；仍要枚举 extension 及 `VK_KHR_present_id2` 等前置能力。Android 17 大屏适配规则对 `android:appCategory="game"` 有豁免，但游戏窗口、Surface 和显示主线仍按 `android-17.0.0_r1` 分析。

## 8. Android 17 源码入口

- Android Vulkan [`swapchain.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/vulkan/libvulkan/swapchain.cpp) 与 [`Surface.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/libs/gui/Surface.cpp)：swapchain 到 BufferQueue。
- [`GameManager.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/core/java/android/app/GameManager.java) 与 [Game Mode API](https://developer.android.com/games/optimize/adpf/gamemode/gamemode-api)：模式与 intervention 边界。
- [`PerformanceHintManager.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/core/java/android/os/PerformanceHintManager.java) 与 [ADPF guide](https://developer.android.com/games/optimize/adpf)：hint session 与持续性能。
- [Swappy / Frame Pacing](https://developer.android.com/games/sdk/frame-pacing)、[Vulkan native engine guide](https://developer.android.com/games/develop/vulkan/native-engine-support) 与 [Vulkan present timing](https://developer.android.com/games/develop/vulkan/frame-pacing-extensions)：pacing、显式同步与 Android 17 扩展。
- [`SurfaceFlinger.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/services/surfaceflinger/SurfaceFlinger.cpp) 与 [`HWComposer.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/services/surfaceflinger/DisplayHardware/HWComposer.cpp)：最终 latch、composition 与 present。
- kernel `android17-6.18-2026-06_r6` 的 [`dma-buf.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/drivers/dma-buf/dma-buf.c)、[`sync_file.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/drivers/dma-buf/sync_file.c) 与 [`dma-fence.h`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/include/linux/dma-fence.h)：固定 kernel tag 下的 buffer 与 fence 语义。

## 9. 常见误判

| 误判 | 正确检查方式 |
|---|---|
| FPS 高就表示触控延迟低 | 对齐输入采样、in-flight frame 和 display present |
| `vkQueueSubmit()` 返回代表 GPU 完成 | 查看 GPU job 与 producer fence signal |
| swap / acquire 等待都是 GPU 慢 | 检查 queue-stuffing、release fence 和主动 pacing |
| Vulkan 一定比 GLES 快 | 比较 engine 实现、driver、workload 和稳定性 |
| Performance Hint 可以锁频 | 它提供 workload 提示，资源决策仍由系统完成 |
| Game Mode performance 一定提高 FPS | OEM 策略可能优先稳定性、温度或分辨率 |
| 云游戏卡顿只看本地 GPU | 分开上行、云端、下行、解码和本地 present |
| OpenXR 帧一定有普通 App FrameTimeline | 以运行时 compositor 和设备 display 事件为准 |

## 总结

本地游戏 trace 从输入、Game / Logic、Render / RHI、GPU submit、swapchain、BufferQueue 一路追到 SF / HWC present。Frame pacing 决定提交节拍和 in-flight 深度，ADPF 与 Game Mode 影响长期资源策略，任何一项都不能替代逐帧证据。

小游戏、云游戏、手机 AR 和头显 XR 各自增加 JS bridge、网络与解码、sensor / pose 或运行时 compositor。先确认 producer 与最终显示边界，再选择对应线程、buffer 和 timestamp。

GENERATED FILE - DO NOT EDIT.
Source: docs/rendering_pipelines/S14_react_native_type.md
Source SHA-256: 2433ab817a1b7f5864cb6aa1e7ca5f9576efb3ceedbbbbaa921824cf0127e7be

# Android Perfetto 系列 - App 出图类型 - React Native 类型

React Native 的额外成本集中在 Android View 绘制之前：JavaScript 执行 React render，Fabric 创建与提交 C++ Shadow Tree，mounting layer 再把 mutation 应用到 Android Host View Tree。主流 RN 组件完成 mount 后，仍由 ViewRoot、HWUI RenderThread、SurfaceFlinger 和 HWC 显示。

本文以 Android 17 / API 37、`android-17.0.0_r1` 为平台源码锚点，kernel 侧以 `android17-6.18-2026-06_r6` 为锚点。React Native 以当前稳定 `v0.86.0` 为框架锚点；Hermes、Reanimated、React Native Skia、Expo 与业务 native module 必须按项目版本核对。

<!--more-->

## 阅读导航

### 本文目录

- 1. Fabric 的 Render、Commit、Mount
- 2. Mount 之后怎样进入 Android 显示
- 3. 线程模型、JSI 与同步调用
- 4. 动画、列表与自绘组件
- 5. 启动、多 Surface 与多实例
- 6. Perfetto 证据链
- 7. Android 12—17 与 RN 版本演进
- 8. Android 17 与 RN 0.86 源码入口
- 9. 类型边界与常见误判
- 总结

### 系列文章目录

1. [Android Perfetto 系列 - App 出图类型 - 总览与识别方法](S01_rendering_types_overview.md)
2. [Android Perfetto 系列 - App 出图类型 - AOSP 标准类型](S02_aosp_standard_type.md)
3. [Android Perfetto 系列 - App 出图类型 - SurfaceView 类型](S03_surfaceview_type.md)
4. [Android Perfetto 系列 - App 出图类型 - TextureView 类型](S04_textureview_type.md)
5. [Android Perfetto 系列 - App 出图类型 - 混合出图类型](S05_mixed_rendering_type.md)
6. [Android Perfetto 系列 - App 出图类型 - 多窗口类型](S06_multi_window_type.md)
7. [Android Perfetto 系列 - App 出图类型 - Software / 离屏类型](S07_software_offscreen_type.md)
8. [Android Perfetto 系列 - App 出图类型 - Native Graphics 类型](S08_native_graphics_type.md)
9. [Android Perfetto 系列 - App 出图类型 - WebView 类型](S09_webview_type.md)
10. [Android Perfetto 系列 - App 出图类型 - Flutter 类型](S10_flutter_type.md)
11. [Android Perfetto 系列 - App 出图类型 - Camera 类型](S11_camera_type.md)
12. [Android Perfetto 系列 - App 出图类型 - Video Overlay / HWC 类型](S12_video_overlay_hwc_type.md)
13. [Android Perfetto 系列 - App 出图类型 - Game 类型](S13_game_type.md)
14. [Android Perfetto 系列 - App 出图类型 - React Native 类型](S14_react_native_type.md)

## 1. Fabric 的 Render、Commit、Mount

React Native 0.82 起只运行 New Architecture；0.86 继续移除 Legacy Architecture 检查和类。Paper + Bridge 仍会出现在旧 App trace 中，但它属于历史兼容分析，不能和 RN 0.86 当作两条并列现行主线。

Fabric 更新分为 Render、Commit、Mount 三个阶段。

```mermaid
flowchart TD
    Event["input / timer / network / native event"]
    Scheduler["React scheduler<br/>priority + update lane"]
    JS["JavaScript thread<br/>application logic + reconciliation"]
    SyncUI["high-priority UI thread path"]
    Render["Fabric Render<br/>create immutable C++ Shadow Tree"]
    Commit["Fabric Commit<br/>Yoga layout + promotion + diff"]
    Mount["Mounting transaction<br/>mutation instructions"]
    Main["Android UI thread<br/>create / update Host Views"]
    ViewRoot["ViewRoot traversal<br/>measure / layout / draw"]
    RT["HWUI RenderThread<br/>GPU work + host buffer"]
    HostBQ["host App Window<br/>BLAST / BufferQueue"]
    Extra["optional native component<br/>SurfaceView / TextureView / media Surface"]
    SF["SurfaceFlinger<br/>snapshot + composition"]
    Display["Composer HAL / display driver<br/>present feedback"]

    Event --> Scheduler --> JS --> Render --> Commit --> Mount --> Main
    Scheduler -. discrete UI event .-> SyncUI --> Render
    Main --> ViewRoot --> RT --> HostBQ --> SF --> Display
    Main --> Extra --> SF
```

Render 阶段执行产品逻辑与 React reconciliation，并为 Host Component 创建 C++ Shadow Node。JSI 让 JavaScript 运行时持有和访问 C++ 对象，省去旧 Bridge 对 JSON-like payload 的批量序列化；业务计算、对象创建与 JavaScript GC 仍会消耗时间。

Commit 阶段完成 Shadow Tree promotion、Yoga layout、tree diff 和 mounting transaction 准备。Text、TextInput 等节点的测量会调用 host platform 能力。React State update、C++ State update 与高优先级 UI event 可以走不同线程和同步策略，因此不能把全部 layout 固定归到一个 JS thread slice。

Mount 阶段把 mutation 应用到 Android Host View Tree。创建 View、设置属性、插入 / 删除 child 和更新 layout 最终要在 Android UI thread 执行。Fabric 的 view flattening 可以减少 Host View 数量，却不会让剩余 View 绕过 Android measure / layout / draw。

到这里可以得到一个实用边界：React commit 完成表示下一棵树可 mount；mount 完成表示 Android View 状态已更新；用户看到画面还要经过 ViewRoot traversal、HWUI、buffer 提交与 display present。

## 2. Mount 之后怎样进入 Android 显示

mounting transaction 在 UI thread 更新 View 后，View invalidation / layout request 触发宿主 `Choreographer` 与 ViewRoot traversal。UI thread 记录 RenderNode / display list，`ThreadedRenderer` 把 frame 交给进程内 HWUI RenderThread，GPU 生成 host App Window buffer。

buffer 经 BLAST / BufferQueue 进入 SurfaceFlinger。Android 17 FrontEnd 生成 layer snapshot，CompositionEngine 与 HWC 协商 DEVICE / CLIENT composition；需要 CLIENT 时由 RenderEngine 生成 client target。`presentAndGetReleaseFences()` 返回 display present fence 与各 layer release fence。

普通 RN `View`、`Text`、`Image` 与 layout 容器都在 host window buffer 中。React Native 文档里的 React “Surface”表示独立 React root / rendering surface 的逻辑边界，不自动对应 Android `Surface`、`SurfaceControl` 或 SF layer。只有组件明确创建 `SurfaceView`、`TextureView`、视频、相机或自绘 Surface 时，显示对象树才会改变。

多个 RN root 可以共享一个 Android window，也可以分布在 Activity、Dialog 或多个 window。`surfaceId` / root tag 用于区分 React tree 与 mounting 目标，SF layer 仍按实际 Android window / Surface 划分。

## 3. 线程模型、JSI 与同步调用

New Architecture 主要涉及 UI thread 和 JavaScript thread，render pipeline 还会使用背景线程。常见更新在 JS thread 完成大部分 Render / Commit，然后把 Mount 调度到 UI thread；高优先级离散事件也可以在 UI thread 同步推进 render pipeline。线程安全来自不可变 Shadow Tree 与 C++ const 约束，不代表所有更新都固定异步。

TurboModules 通过 JSI 提供 native 能力。同步 JSI 调用可以减少异步往返，也可能让 JS thread 直接等待 native 锁、I/O 或重计算；native 同步回调到 UI thread 还可能形成反向依赖。Perfetto 要按调用栈和线程状态确认等待方向。

Hermes V1 从 RN 0.84 起成为 Android 与 iOS 默认 JavaScript engine。JS parse / bytecode、GC 与运行时事件名称会随 Hermes 版本变化。0.86 App 也可以包含业务定制运行时或调试配置，不能只凭 RN 版本推断所有 JS 性能特征。

## 4. 动画、列表与自绘组件

JS-driven animation 每帧需要 JavaScript 计算与状态更新，JS 长任务会直接破坏动画节拍。Native Animated、LayoutAnimation、Reanimated worklet 或 RN 0.85 的新 animation backend 可以把部分工作移出普通 JS 更新路径；最终属性 mutation、View traversal 或自绘提交仍要按实际实现追踪。

列表卡顿要拆成数据准备、React render、Shadow Tree diff、mount、Android View 创建 / 绑定、图片解码和 HWUI 绘制。Fabric 减少跨边界序列化并提供 view flattening，过量组件、频繁 key 变化、无效重渲染和大图仍会产生真实成本。

React Native Skia 等自绘库通过 JSI 接入自己的 renderer。后半段可能使用 TextureView 并回到 host window，也可能使用 SurfaceView / 独立 Surface。必须记录 library 版本和实际 View / layer tree；“使用 Skia”本身不能确定 SF 对象。

WebView、视频、相机和地图组件也可能增加独立 Surface 或外部纹理。此时 RN 负责组件生命周期与几何，媒体 / camera / native renderer 负责像素生产，两个 producer 节拍要分别验证。

## 5. 启动、多 Surface 与多实例

冷启动包含 APK / native library 加载、ReactHost / 运行时创建、Hermes 初始化、bundle 读取、native module 注册、首棵 Shadow Tree、首次 mount 与第一帧 HWUI。稳态滚动只覆盖其中一小部分，不能用稳态 trace 解释白屏启动。

预热运行时或复用 React instance 可以缩短后续 Surface 启动，但会增加内存常驻、module 状态共享和生命周期管理成本。多个 React Surface 共享 JS 运行时时，一处长 JS task 可能阻塞其他 Surface 更新；它们是否共享 Android window 则决定后半段是同一 FrameTimeline 还是多个 window token。

RN 0.86 在 Android 15+ 提供更完整的 edge-to-edge 支持。Insets 变化、system bar、keyboard 与 modal 会触发 Android layout 和 RN 状态更新。大屏 / 多窗口 resize 还可能同时触发 host configuration、surface size 与 React layout，不能只看 JS reconciliation。

## 6. Perfetto 证据链

第一步记录 RN 版本、New Architecture、Hermes 版本、release / debug build、Expo / Reanimated / Skia 版本、React root 数量和 Android window / Surface 结构。RN 0.82+不再接受“是否启用 Legacy Architecture”作为运行时分支。

第二步按连续帧标出 event、JS render、commit / layout、mounting transaction、UI thread mutation、ViewRoot traversal、HWUI `DrawFrame`、host queue、SF latch 与 display present。

| 现象 | 可能瓶颈 | 验证证据 |
|---|---|---|
| JS thread 长时间 Running | 业务逻辑、reconciliation、序列化、GC | JS marker、Hermes event、CPU profile |
| Commit / layout 晚 | Shadow Tree 大、Yoga、host text 测量、commit 重试 | Fabric marker、tree 规模、text measure |
| Mount 晚 | mutation 多、View 创建、UI thread 抢占 | mounting transaction、主线程状态 |
| Mount 已结束但 traversal 晚 | Android 主线程其他 callback、layout / draw | Choreographer、ViewRoot、Runnable 延迟 |
| host frame 已 queue 但 present 晚 | acquire fence、SF / HWC、CLIENT composition | host layer、FrameTimeline、HWC |
| JS 和 host 都正常但自绘组件晚 | Skia / video / camera 独立 producer | 对应 Surface、GPU / codec / camera fence |

JS slice 的 wall time 要结合 Running、Runnable、Sleeping 判断。UI thread 上一个长 Fabric slice 也可能包含等待，不应全部算作 C++ 计算。frame id、commit number、surfaceId、host frame number 与 layer id 能关联多少就保留多少。

kernel `android17-6.18-2026-06_r6` 下，host window 与自绘 / 媒体 Surface 使用 dma-buf，GPU / HWC 通过 dma-fence / sync_file 同步。JavaScript 和 Fabric CPU 问题主要看调度、futex、Binder、page fault、GC 与 memory pressure；Surface 类组件再补 GPU / display driver 证据。

## 7. Android 12—17 与 RN 版本演进

RN 随 App 发布，Android 版本与 RN 版本没有一一对应关系。下面同时保留平台变化和同期 RN 架构演进，排障仍以 APK 内实际版本为准。

### Android 12 / API 31

BLAST / FrameTimeline 与现代 HWUI 窗口路径成为显示基线。当时线上 RN 仍以 Paper / Bridge 为主，New Architecture 处于早期 opt-in 阶段；今天运行在 Android 12 上的新 App 也可以使用 Fabric，OS 版本不能确定架构。

### Android 13 / API 33

HWC 进入 AIDL，Choreographer / SurfaceControl 提供更完整 frame timeline 信息。RN 前段没有由 Android 13 强制改变，Paper 或 Fabric 取决于 App 携带的 RN 版本。

### Android 14 / API 34

Android View / HWUI / SF 主线保持稳定。React Native 0.76 在 2024 年把 New Architecture 设为新项目默认，但旧项目仍可选择 Legacy；这属于 RN 发布线，不是 Android 14 平台行为。

### Android 15 / API 35

16 KB page size 要求 React Native engine、Hermes 和所有 native module 满足 ELF / APK 对齐；RN 0.77 明确加入 Android 16 KB page 支持。Android 15 edge-to-edge 变化也会影响宿主 insets 与 layout。

### Android 16 / API 36

RN 0.81 加入 Android 16 支持；RN 0.82 随后成为 New Architecture-only，忽略关闭 New Architecture 的配置。RN 0.84 把 Hermes V1 设为默认并继续删除 Legacy 代码。运行在 Android 16 的旧 APK 仍保持其原有 RN 架构。

### Android 17 / API 37

当前稳定 RN 0.86 继续移除 Legacy Architecture 检查，并补强 Android 15+ edge-to-edge 与 mounting 同步。平台侧统一按 `android-17.0.0_r1` 的 ViewRoot、HWUI FrontEnd / SF 与 AIDL Composer 分析；target 37 可能进入 Android 17 的 concurrent `MessageQueue` 路径，改变主线程 queue 争用与 trace 形态，但不会绕过 Fabric Mount 与 ViewRoot traversal。

## 8. Android 17 与 RN 0.86 源码入口

- [RN Architecture Overview](https://reactnative.dev/architecture/overview)、[Render / Commit / Mount](https://reactnative.dev/architecture/render-pipeline) 与 [Threading Model](https://reactnative.dev/architecture/threading-model)：Fabric 阶段与线程边界。
- [React Native 0.82](https://reactnative.dev/blog/2025/10/08/react-native-0.82)、[0.84](https://reactnative.dev/blog/2026/02/11/react-native-0.84) 与 [0.86](https://reactnative.dev/blog/2026/06/11/react-native-0.86)：New Architecture-only、Hermes V1 和当前版本演进。
- RN 0.86 [`ReactAndroid`](https://github.com/react/react-native/tree/v0.86.0/packages/react-native/ReactAndroid) 与 [`ReactCommon`](https://github.com/react/react-native/tree/v0.86.0/packages/react-native/ReactCommon)：Android mounting、Fabric 与 JSI 源码。
- Android 17 [`ViewRootImpl.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/core/java/android/view/ViewRootImpl.java)、[`ThreadedRenderer.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/core/java/android/view/ThreadedRenderer.java) 与 [`SurfaceFlinger.cpp`](https://android.googlesource.com/platform/frameworks/native/+/android-17.0.0_r1/services/surfaceflinger/SurfaceFlinger.cpp)：mount 后的 Android 显示主线。
- Android 17 [`CombinedMessageQueue/MessageQueue.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/core/java/android/os/CombinedMessageQueue/MessageQueue.java)、[`LegacyMessageQueue/MessageQueue.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/core/java/android/os/LegacyMessageQueue/MessageQueue.java) 与 [`Looper.java`](https://android.googlesource.com/platform/frameworks/base/+/android-17.0.0_r1/core/java/android/os/Looper.java)：target 37 下主线程队列语义与 trace 解释入口。
- kernel `android17-6.18-2026-06_r6` 的 [`dma-buf.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/drivers/dma-buf/dma-buf.c)、[`sync_file.c`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/drivers/dma-buf/sync_file.c) 与 [`dma-fence.h`](https://android.googlesource.com/kernel/common/+/refs/tags/android17-6.18-2026-06_r6/include/linux/dma-fence.h)：固定 kernel tag 下的 buffer 与 fence 语义。

## 9. 类型边界与常见误判

普通 RN 组件最终是 Android Host View；React Native Skia、视频、Camera、WebView 和地图可能另有 Surface 或外部纹理。先确认实际 View / layer tree，再决定是否需要追加对应 producer 分析。

| 误判 | 正确检查方式 |
|---|---|
| RN 0.86 仍可在 Paper 和 Fabric 之间选择 | 0.82 起只运行 New Architecture，旧架构只用于旧 App 分析 |
| JSI 消除了 JS 与 native 之间的成本 | 仍有 JS 计算、对象转换、同步等待和 native 工作 |
| React commit 完成就是 Android 已绘制 | 继续追 Mount、ViewRoot、HWUI、SF 与 present |
| React Surface 等于 Android SurfaceControl | 它是 React root 逻辑边界，按实际 Android 对象验证 |
| Fabric 所有工作都固定在 JS thread | 高优先级场景可在 UI thread 同步执行 |
| Hermes V1 消除了 JavaScript 卡顿 | 业务长任务、GC 压力和同步 native 调用仍会超预算 |
| RN Skia 固定形成独立 SF layer | 查具体 library 版本、TextureView / SurfaceView 与 layer tree |
| JS frame 正常就能排除 RN 问题 | Commit、Mount、host traversal 或自绘 producer 仍可能迟到 |

## 总结

React Native 0.86 的主线是 New Architecture：JavaScript 执行 Render，Fabric 创建并提交 C++ Shadow Tree，Mounting Layer 把 mutation 应用到 Android Host View，随后进入 ViewRoot、HWUI、SurfaceFlinger 与 HWC。

Perfetto 分析要把 JS、Commit / Layout、Mount、Android traversal、HWUI 和 display present 分开。自绘、视频、相机或 WebView 组件若创建额外 Surface，再为对应 producer 建立独立的 buffer 与 fence 时间线。

{
  "adapters": [
    {
      "branches": [
        "api<=28",
        "api29-32",
        "api>=33"
      ],
      "id": "official_android_startup_tags",
      "source": "perfetto stdlib android/startup/startups.sql"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.startup.startups",
    "android.startup.time_to_display",
    "android.broadcasts"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "%Choreographer%doFrame%",
    "%activityResume%",
    "%activityStart%",
    "%bindApplication%"
  ],
  "skill_id": "ams_module",
  "steps": {
    "broadcast_analysis": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "ams_module/broadcast_analysis"
    },
    "startup_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "startup_phases": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "ams_module/startup_phases"
    },
    "startup_timing": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "ams_module/startup_timing"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.app_wakelocks",
    "android.battery_stats",
    "android.standby_bucket",
    "android.freezer"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "Freeze *:*",
    "android_app_wakelocks",
    "android_battery_stats_event_slices",
    "android_freezer_events",
    "android_freezer_state_statsd",
    "android_standby_bucket",
    "app_freeze_changed",
    "app_standby_bucket_changed",
    "battery_stats.longwake"
  ],
  "skill_id": "android_app_background_power_state",
  "steps": {
    "app_wakelock_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_app_background_power_state/app_wakelock_summary"
    },
    "app_wakelock_summary_battery_stats": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_app_background_power_state/app_wakelock_summary_battery_stats"
    },
    "freezer_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_app_background_power_state/freezer_summary"
    },
    "freezer_summary_slices": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_app_background_power_state/freezer_summary_slices"
    },
    "power_state_capability": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_app_background_power_state/power_state_capability"
    },
    "standby_bucket_residency": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_app_background_power_state/standby_bucket_residency"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.bitmaps",
    "android.memory.heap_graph.bitmap"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "heap_graph_bitmaps"
  ],
  "skill_id": "android_bitmap_memory_per_process",
  "steps": {
    "bitmap_memory": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_bitmap_memory_per_process/bitmap_memory"
    },
    "heap_bitmap_availability": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_bitmap_memory_per_process/heap_bitmap_availability"
    },
    "heap_bitmap_metadata": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_bitmap_memory_per_process/heap_bitmap_metadata"
    },
    "heap_bitmap_sender_attribution": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_bitmap_memory_per_process/heap_bitmap_sender_attribution"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.dvfs"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "android_dvfs_counter_stats",
  "steps": {
    "dvfs_stats": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_dvfs_counter_stats/dvfs_stats"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.gpu.work_period"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "android_gpu_work_period_track",
  "steps": {
    "gpu_work": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_gpu_work_period_track/gpu_work"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.memory.heap_graph.dominator_class_tree",
    "graphs.scan",
    "graphs.hierarchy"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "android_heap_dominator_path_extract",
  "steps": {
    "data_check": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_heap_dominator_path_extract/data_check"
    },
    "dominator_paths": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_heap_dominator_path_extract/dominator_paths"
    },
    "dominator_tree_pass": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_heap_dominator_path_extract/dominator_tree_pass"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.memory.heap_graph.heap_graph_class_aggregation",
    "android.memory.heap_graph.heap_graph_stats"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "android_heap_graph_class_growth",
  "steps": {
    "class_dump_inventory": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_heap_graph_class_growth/class_dump_inventory"
    },
    "class_growth_availability": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_heap_graph_class_growth/class_growth_availability"
    },
    "class_growth_within_trace": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_heap_graph_class_growth/class_growth_within_trace"
    },
    "class_ranking": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_heap_graph_class_growth/class_ranking"
    },
    "heap_class_table": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_heap_graph_class_growth/heap_class_table"
    },
    "requested_classes": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_heap_graph_class_growth/requested_classes"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.memory.heap_graph.excluded_refs"
  ],
  "required_tables": [
    "heap_graph_object",
    "heap_graph_class",
    "heap_graph_reference"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "*",
    "*onCreate*",
    "*onDestroy*",
    "*onDestroyView*",
    "*onPause*",
    "*onResume*",
    "*onStart*",
    "*onStop*"
  ],
  "skill_id": "android_heap_graph_leak_candidates",
  "steps": {
    "leak_candidates": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_heap_graph_leak_candidates/leak_candidates"
    },
    "reference_holders": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_heap_graph_leak_candidates/reference_holders"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.memory.heap_graph.heap_graph_stats",
    "android.memory.heap_graph.class_summary_tree"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "*Activity*",
    "*Fragment*",
    "truncated"
  ],
  "skill_id": "android_heap_graph_summary",
  "steps": {
    "heap_graph_availability": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_heap_graph_summary/heap_graph_availability"
    },
    "heap_graph_dump_sizes": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_heap_graph_summary/heap_graph_dump_sizes"
    },
    "heap_graph_samples": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_heap_graph_summary/heap_graph_samples"
    },
    "heap_graph_truncation": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_heap_graph_summary/heap_graph_truncation"
    },
    "top_retained_classes": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_heap_graph_summary/top_retained_classes"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.job_scheduler"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "android_job_scheduler_events",
  "steps": {
    "job_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_job_scheduler_events/job_events"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.kernel_wakelocks"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "android_kernel_wakelock_summary",
  "steps": {
    "wakelock_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_kernel_wakelock_summary/wakelock_summary"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "prelude.after_eof.memory",
    "prelude.after_eof.views",
    "android.memory.heap_graph.heap_graph_stats",
    "android.memory.heap_graph.class_summary_tree"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "android_memory_v57_ai_diagnostics",
  "steps": {
    "data_check": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_memory_v57_ai_diagnostics/data_check"
    },
    "heap_graph_repeated_objects": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_memory_v57_ai_diagnostics/heap_graph_repeated_objects"
    },
    "heap_graph_size_frequencies": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_memory_v57_ai_diagnostics/heap_graph_size_frequencies"
    },
    "heap_profile_hotspots": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "no_data_contract": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_memory_v57_ai_diagnostics/no_data_contract"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.process_state"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "_android_process_state_intervals"
  ],
  "skill_id": "android_process_state_residency",
  "steps": {
    "process_state_capability": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_process_state_residency/process_state_capability"
    },
    "process_state_data": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_process_state_residency/process_state_data"
    },
    "process_state_last_observed": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_process_state_residency/process_state_last_observed"
    },
    "process_state_residency": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_process_state_residency/process_state_residency"
    },
    "process_state_transitions": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "android_process_state_residency/process_state_transitions"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.anrs",
    "android.binder",
    "android.memory.lmk"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "system_server"
  ],
  "skill_id": "anr_analysis",
  "steps": {
    "analyze_anr_events": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "anr_detection": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_analysis/anr_detection"
    },
    "anr_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "anr_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_analysis/anr_overview"
    },
    "anr_process_io_wait": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_analysis/anr_process_io_wait"
    },
    "futex_wait_probe": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "get_anr_context": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "get_anr_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_analysis/get_anr_events"
    },
    "init_cpu_topology": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "io_load": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_analysis/io_load"
    },
    "memory_pressure": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_analysis/memory_pressure"
    },
    "system_cpu_health": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_analysis/system_cpu_health"
    },
    "system_freeze_check": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_analysis/system_freeze_check"
    },
    "top_cpu_processes": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_analysis/top_cpu_processes"
    },
    "trigger_classification": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_analysis/trigger_classification"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.anrs"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "anr_context_in_range",
  "steps": {}
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.binder",
    "linux.cpu.frequency",
    "android.monitor_contention"
  ],
  "required_tables": [
    "slice",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${process_name}",
    "${process_name}:*",
    "%DrawFrame%",
    "%dequeueBuffer%",
    "%nSyncDraw%",
    "%syncFrameState%",
    "Binder:%",
    "RenderThread",
    "android_logs",
    "slice",
    "thread_state",
    "thread_track"
  ],
  "skill_id": "anr_detail",
  "steps": {
    "anr_event_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "anr_info": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_detail/anr_info"
    },
    "anr_logcat_context": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_detail/anr_logcat_context"
    },
    "anr_logcat_evidence_gap": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_detail/anr_logcat_evidence_gap"
    },
    "app_freeze_check": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_detail/app_freeze_check"
    },
    "binder_calls": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "blocking_reasons": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "direct_blocker_classification": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_detail/direct_blocker_classification"
    },
    "direct_blocker_evidence_gap": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_detail/direct_blocker_evidence_gap"
    },
    "direct_blocker_slice_classification": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_detail/direct_blocker_slice_classification"
    },
    "direct_blocker_slice_evidence_gap": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_detail/direct_blocker_slice_evidence_gap"
    },
    "init_cpu_topology": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "lock_contention": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_detail/lock_contention"
    },
    "logcat_availability": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_detail/logcat_availability"
    },
    "main_thread_quadrant": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_detail/main_thread_quadrant"
    },
    "main_thread_slices": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "main_thread_sync_binder": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "render_thread_analysis": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_detail/render_thread_analysis"
    },
    "sched_latency": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "system_context_window": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_detail/system_context_window"
    },
    "system_cpu_context": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "system_task_handoffs": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "system_task_summary": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "thread_evidence_availability": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_detail/thread_evidence_availability"
    },
    "wakeup_chain": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_detail/wakeup_chain"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.binder",
    "android.monitor_contention"
  ],
  "required_tables": [
    "thread_state",
    "thread",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${process_name}",
    "${process_name}:*",
    "*futex*"
  ],
  "skill_id": "anr_main_thread_blocking",
  "steps": {
    "binder_blocking": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_main_thread_blocking/binder_blocking"
    },
    "blocked_functions": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_main_thread_blocking/blocked_functions"
    },
    "lock_contention": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_main_thread_blocking/lock_contention"
    },
    "main_thread_state": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_main_thread_blocking/main_thread_state"
    },
    "wakeup_chain": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "anr_main_thread_blocking/wakeup_chain"
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.frames.timeline"
  ],
  "required_tables": [
    "actual_frame_timeline_slice"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*"
  ],
  "skill_id": "app_frame_production",
  "steps": {
    "app_production_stats": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "app_frame_production/app_production_stats"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "slice"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "*Fragment*",
    "*activityPause*",
    "*activityResume*",
    "*activityStart*",
    "*bindApplication*",
    "*inflate*",
    "*onCreate*",
    "*onDestroy*",
    "*onPause*",
    "*onResume*",
    "*onStart*",
    "*onStop*",
    "*performCreate*",
    "completed:*",
    "launching:*"
  ],
  "skill_id": "app_lifecycle_in_range",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.app_process_starts"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*"
  ],
  "skill_id": "app_process_starts_summary",
  "steps": {
    "process_starts": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "app_process_starts_summary/process_starts"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "%JIT%",
    "%compile%"
  ],
  "skill_id": "art_module",
  "steps": {
    "art_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "gc_during_main_thread": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "art_module/gc_during_main_thread"
    },
    "gc_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "art_module/gc_events"
    },
    "gc_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "art_module/gc_overview"
    },
    "gc_totals": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "art_module/gc_totals"
    },
    "jit_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "art_module/jit_events"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.battery"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "battery_charge_timeline",
  "steps": {
    "battery_samples": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "battery_charge_timeline/battery_samples"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.battery.doze"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "battery_doze_state_timeline",
  "steps": {
    "deep_idle_intervals": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "battery_doze_state_timeline/deep_idle_intervals"
    },
    "light_idle_intervals": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "battery_doze_state_timeline/light_idle_intervals"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.battery",
    "android.battery.doze",
    "android.kernel_wakelocks",
    "android.wakeups",
    "android.screen_state",
    "android.job_scheduler",
    "android.network_packets",
    "linux.cpu.idle"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "battery_drain_attribution",
  "steps": {
    "app_background_power": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "battery_charge": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "battery_drain_rate": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "doze_state": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "job_scheduler": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "modem_network": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "network_activity": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "screen_off_cpu": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "suspend_wakeup": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "wakelock_summary": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "wakeup_frequency": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.battery"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "battery_drain_rate_summary",
  "steps": {
    "drain_rate": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "battery_drain_rate_summary/drain_rate"
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.binder",
    "android.frames.timeline"
  ],
  "required_tables": [
    "slice"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${target_process.data[0].process_name}"
  ],
  "skill_id": "binder_analysis",
  "steps": {
    "analyze_slow_binder": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "binder_blocking_analysis": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "binder_analysis/binder_blocking_analysis"
    },
    "binder_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "binder_frame_correlation": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "binder_analysis/binder_frame_correlation"
    },
    "binder_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "binder_analysis/binder_overview"
    },
    "check_binder": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "binder_analysis/check_binder"
    },
    "get_process": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "binder_analysis/get_process"
    },
    "incoming_calls": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "binder_analysis/incoming_calls"
    },
    "main_thread_sync_binder": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "binder_analysis/main_thread_sync_binder"
    },
    "outgoing_by_interface": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "binder_analysis/outgoing_by_interface"
    },
    "server_response_analysis": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "binder_analysis/server_response_analysis"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.binder"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*"
  ],
  "skill_id": "binder_blocking_in_range",
  "steps": {}
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "slice"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${process_name}",
    "${process_name}:*"
  ],
  "skill_id": "binder_detail",
  "steps": {
    "binder_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "binder_info": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "binder_detail/binder_info"
    },
    "blocking_analysis": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "binder_detail/blocking_analysis"
    },
    "cpu_core_analysis": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "binder_detail/cpu_core_analysis"
    },
    "init_cpu_topology": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "quadrant_analysis": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "binder_detail/quadrant_analysis"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.binder"
  ],
  "required_tables": [
    "slice"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "binder_in_range",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.binder"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "binder_module",
  "steps": {
    "binder_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "binder_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "binder_module/binder_summary"
    },
    "blocking_analysis": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "binder_module/blocking_analysis"
    },
    "long_sync_calls": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "binder_module/long_sync_calls"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.binder_breakdown",
    "android.binder"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "binder_root_cause",
  "steps": {
    "blame_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "binder_root_cause/blame_summary"
    },
    "slow_binder_breakdown": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "binder_root_cause/slow_binder_breakdown"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.binder"
  ],
  "required_tables": [
    "slice"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "binder_storm_detection",
  "steps": {
    "binder_density": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "binder_storm_detection/binder_density"
    },
    "buffer_pressure": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "binder_storm_detection/buffer_pressure"
    },
    "burst_detection": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "binder_storm_detection/burst_detection"
    },
    "callback_loops": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "binder_storm_detection/callback_loops"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "thread_state",
    "thread",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${process_name}",
    "${process_name}:*"
  ],
  "skill_id": "blocking_chain_analysis",
  "steps": {
    "blocked_function_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "blocking_chain_analysis/blocked_function_summary"
    },
    "thread_state_distribution": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "blocking_chain_analysis/thread_state_distribution"
    },
    "waker_chain": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "blocking_chain_analysis/waker_chain"
    },
    "wakeup_chain_trace": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "blocking_chain_analysis/wakeup_chain_trace"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.block_io"
  ],
  "required_tables": [
    "thread_state"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "block_io_analysis",
  "steps": {
    "data_check": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "block_io_analysis/data_check"
    },
    "device_io_stats": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "block_io_analysis/device_io_stats"
    },
    "high_queue_periods": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "block_io_analysis/high_queue_periods"
    },
    "io_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "block_io_analysis/io_overview"
    },
    "io_queue_depth": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "block_io_analysis/io_queue_depth"
    },
    "io_thread_blocking": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "block_io_analysis/io_thread_blocking"
    },
    "long_io_operations": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "block_io_analysis/long_io_operations"
    },
    "root_cause_classification": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "block_io_analysis/root_cause_classification"
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "slice",
    "thread",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "*BLASTBufferQueue*",
    "*acquireBuffer*",
    "*applyTransaction*",
    "*latchBuffer*",
    "*queueBuffer*",
    "*setTransactionState*",
    "surfaceflinger"
  ],
  "skill_id": "buffer_transaction_lifecycle",
  "steps": {
    "apply_transaction_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "buffer_transaction_lifecycle/apply_transaction_summary"
    },
    "per_layer_transactions": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "buffer_transaction_lifecycle/per_layer_transactions"
    },
    "queue_to_transaction_delay": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "buffer_transaction_lifecycle/queue_to_transaction_delay"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "counter",
    "counter_track"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "cache_miss_impact",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "%.apk",
    "%.dex",
    "%.so",
    "%kernel%",
    "%vmlinux%"
  ],
  "skill_id": "callstack_analysis",
  "steps": {
    "analysis_conclusion": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "callstack_analysis/analysis_conclusion"
    },
    "caller_analysis": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "callstack_analysis/caller_analysis"
    },
    "check_samples": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "callstack_analysis/check_samples"
    },
    "hot_functions": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "callstack_analysis/hot_functions"
    },
    "module_distribution": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "callstack_analysis/module_distribution"
    },
    "thread_hotspots": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "callstack_analysis/thread_hotspots"
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    },
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "slices.with_context",
    "android.binder",
    "android.frames.timeline",
    "android.memory.dmabuf",
    "linux.cpu.frequency",
    "pixel.camera"
  ],
  "required_tables": [
    "slice",
    "thread",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "mem.ion_change*"
  ],
  "skill_id": "camera_trace_evidence",
  "steps": {
    "camera_binder_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "camera_trace_evidence/camera_binder_summary"
    },
    "camera_dmabuf_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "camera_trace_evidence/camera_dmabuf_summary"
    },
    "camera_process_candidates": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "camera_trace_evidence/camera_process_candidates"
    },
    "camera_slice_candidates": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "camera_trace_evidence/camera_slice_candidates"
    },
    "evidence_coverage": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "camera_trace_evidence/evidence_coverage"
    },
    "pixel_camera_stage_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "camera_trace_evidence/pixel_camera_stage_summary"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "slice",
    "thread",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "*Animation*",
    "*Choreographer#doFrame*",
    "*Choreographer*",
    "*Draw*",
    "*DrawFrame*",
    "*Input*",
    "*Layout*",
    "*Measure*",
    "*Traversal*",
    "*acquireBuffer*",
    "*animation*",
    "*dequeueBuffer*",
    "*doFrame*",
    "*draw*",
    "*eglSwapBuffers*",
    "*input*",
    "*layout*",
    "*measure*",
    "*queueBuffer*",
    "*syncFrameState*",
    "*traversal*"
  ],
  "skill_id": "choreographer_module",
  "steps": {
    "callback_breakdown": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "choreographer_module/callback_breakdown"
    },
    "choreographer_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "doframe_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "choreographer_module/doframe_overview"
    },
    "doframe_timeline": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "choreographer_module/doframe_timeline"
    },
    "frame_pipeline": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "choreographer_module/frame_pipeline"
    },
    "long_frames": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "choreographer_module/long_frames"
    },
    "view_traversal": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "choreographer_module/view_traversal"
    },
    "vsync_timing": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "chrome.chrome_scrolls",
    "chrome.chrome_scrolls_v4",
    "chrome.scroll_jank.scroll_jank_intervals",
    "chrome.scroll_jank_v4",
    "chrome.scroll_jank_tagging"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "Extend_VSync"
  ],
  "skill_id": "chrome_scroll_jank_frame_timeline",
  "steps": {
    "chrome_preferred_frame_timeline": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "chrome_scroll_jank_frame_timeline/chrome_preferred_frame_timeline"
    },
    "chrome_scroll_v3_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "chrome_scroll_jank_frame_timeline/chrome_scroll_v3_summary"
    },
    "chrome_scroll_v4_janky_frames": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "chrome_scroll_jank_frame_timeline/chrome_scroll_v4_janky_frames"
    },
    "chrome_trace_availability": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "chrome_scroll_jank_frame_timeline/chrome_trace_availability"
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    },
    {
      "id": "android_input_source",
      "selection": "data-source descriptor, build type, config, then rows",
      "version_hint": {
        "proto_input_min_api_hint": 34
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.input",
    "android.binder",
    "android.frames.timeline"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "${target_process.data[0].process_name}"
  ],
  "skill_id": "click_response_analysis",
  "steps": {
    "analyze_slow_events": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "check_input_data": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "click_response_analysis/check_input_data"
    },
    "click_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "get_process": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "click_response_analysis/get_process"
    },
    "input_binder_calls": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "click_response_analysis/input_binder_calls"
    },
    "input_latency_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "click_response_analysis/input_latency_overview"
    },
    "input_thread_state": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "click_response_analysis/input_thread_state"
    },
    "input_to_frame": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "click_response_analysis/input_to_frame"
    },
    "latency_by_event_type": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "click_response_analysis/latency_by_event_type"
    },
    "latency_by_window": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "click_response_analysis/latency_by_window"
    },
    "latency_distribution": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "click_response_analysis/latency_distribution"
    },
    "slow_input_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "click_response_analysis/slow_input_events"
    }
  }
}

{
  "adapters": [
    {
      "id": "android_input_source",
      "selection": "data-source descriptor, build type, config, then rows",
      "version_hint": {
        "proto_input_min_api_hint": 34
      }
    },
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.input",
    "android.binder",
    "linux.cpu.frequency"
  ],
  "required_tables": [
    "thread",
    "process",
    "thread_state",
    "sched_slice"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${process_name}",
    "${process_name}:*",
    "*InputDispatcher*",
    "*InputEvent*",
    "*InputReader*",
    "*deliverInput*",
    "*dispatchMotion*",
    "/system/bin/%",
    "UnwantedInteractionBlocker::notifyMotion*",
    "aq:pending:deliver*",
    "system_server"
  ],
  "skill_id": "click_response_detail",
  "steps": {
    "binder_analysis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "blocking_analysis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "click_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "cpu_core_analysis": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "click_response_detail/cpu_core_analysis"
    },
    "event_info": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "click_response_detail/event_info"
    },
    "init_cpu_topology": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "input_app_receive": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "click_response_detail/input_app_receive"
    },
    "input_dispatch_breakdown": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "click_response_detail/input_dispatch_breakdown"
    },
    "input_pipeline_lifecycle": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "click_response_detail/input_pipeline_lifecycle"
    },
    "main_thread_file_io": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "main_thread_sync_binder": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "quadrant_analysis": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "click_response_detail/quadrant_analysis"
    },
    "sched_latency": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "system_context_window": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "click_response_detail/system_context_window"
    },
    "system_cpu_context": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "system_task_handoffs": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "system_task_summary": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "slices.with_context",
    "android.process_metadata"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "code_pinpoint",
  "steps": {
    "hot_slices": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "code_pinpoint/hot_slices"
    },
    "native_symbols": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "code_pinpoint/native_symbols"
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.frames.timeline",
    "slices.with_context"
  ],
  "required_tables": [
    "slice",
    "thread_track",
    "thread",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "*CompositionLocal*",
    "Compose:*",
    "Recompos*",
    "actual_frame_timeline_slice"
  ],
  "skill_id": "compose_recomposition_hotspot",
  "steps": {
    "composition_frequency": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "compose_recomposition_hotspot/composition_frequency"
    },
    "frame_timeline_check": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "compose_recomposition_hotspot/frame_timeline_check"
    },
    "recomposition_frame_overlap": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "compose_recomposition_hotspot/recomposition_frame_overlap"
    },
    "recomposition_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "compose_recomposition_hotspot/recomposition_overview"
    },
    "slow_recompositions": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "compose_recomposition_hotspot/slow_recompositions"
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.frames.timeline",
    "android.frames.jank_type"
  ],
  "required_tables": [
    "actual_frame_timeline_slice"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "VSYNC-sf"
  ],
  "skill_id": "consumer_jank_detection",
  "steps": {
    "consumer_jank_frames": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "consumer_jank_detection/consumer_jank_frames"
    },
    "consumer_jank_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "consumer_jank_detection/consumer_jank_summary"
    },
    "jank_severity_distribution": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "consumer_jank_detection/jank_severity_distribution"
    },
    "presentation_cadence_audit": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "consumer_jank_detection/presentation_cadence_audit"
    },
    "vsync_config": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "consumer_jank_detection/vsync_config"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.cpu.frequency"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "%.%"
  ],
  "skill_id": "cpu_analysis",
  "steps": {
    "blocked_functions": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_analysis/blocked_functions"
    },
    "cache_counter_check": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_analysis/cache_counter_check"
    },
    "cache_miss_probe": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "core_type_stats": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_analysis/core_type_stats"
    },
    "cpu_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "cpu_frequency_distribution": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_analysis/cpu_frequency_distribution"
    },
    "get_process": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_analysis/get_process"
    },
    "init_cpu_topology": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "main_thread_cores": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_analysis/main_thread_cores"
    },
    "main_thread_states": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_analysis/main_thread_states"
    },
    "runnable_latency": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_analysis/runnable_latency"
    },
    "thread_affinity_probe": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "thread_cpu_usage": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_analysis/thread_cpu_usage"
    },
    "wakeup_chain": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_analysis/wakeup_chain"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.process_metadata"
  ],
  "required_tables": [
    "sched_slice",
    "thread"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "cpu_anomalous_threads_in_range",
  "steps": {
    "anomalous_threads": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_anomalous_threads_in_range/anomalous_threads"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "cpu_cluster_load_in_range",
  "steps": {
    "cluster_load": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_cluster_load_in_range/cluster_load"
    },
    "init_cpu_topology": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.cpu.cluster_type"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "cpu_cluster_mapping_view",
  "steps": {
    "cluster_mapping": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_cluster_mapping_view/cluster_mapping"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.cpu.frequency",
    "android.process_metadata"
  ],
  "required_tables": [
    "counter",
    "counter_track",
    "cpu_counter_track"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "cpu_frequency_limit_attribution",
  "steps": {
    "analysis_window": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_frequency_limit_attribution/analysis_window"
    },
    "attribution_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_frequency_limit_attribution/attribution_summary"
    },
    "cooling_overview": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "data_check": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_frequency_limit_attribution/data_check"
    },
    "diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "episode_drilldown": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "episodes": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_frequency_limit_attribution/episodes"
    },
    "limit_overview": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "no_limit_capture_advice": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_frequency_limit_attribution/no_limit_capture_advice"
    },
    "no_limit_throttle_observation": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "vendor_signal_discovery": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_frequency_limit_attribution/vendor_signal_discovery"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.cpu.frequency",
    "android.process_metadata"
  ],
  "required_tables": [
    "counter",
    "counter_track",
    "sched_slice"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "cpu_frequency_limit_episode",
  "steps": {
    "before_anomalies": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "before_workload": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "episode_windows": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_frequency_limit_episode/episode_windows"
    },
    "limit_onsets": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_frequency_limit_episode/limit_onsets"
    },
    "non_cpu_heat_context": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_frequency_limit_episode/non_cpu_heat_context"
    },
    "temperature_context": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_frequency_limit_episode/temperature_context"
    },
    "who_cooling": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_frequency_limit_episode/who_cooling"
    },
    "who_daemon": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_frequency_limit_episode/who_daemon"
    },
    "who_verdict": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_frequency_limit_episode/who_verdict"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.cpu.frequency"
  ],
  "required_tables": [
    "cpu_counter_track",
    "counter"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "cpu_freq_limit_timeline",
  "steps": {
    "limit_data_check": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_freq_limit_timeline/limit_data_check"
    },
    "limit_episodes": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_freq_limit_timeline/limit_episodes"
    },
    "limit_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_freq_limit_timeline/limit_events"
    },
    "limit_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_freq_limit_timeline/limit_summary"
    },
    "limit_unavailable": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_freq_limit_timeline/limit_unavailable"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.cpu.frequency",
    "android.cpu.cluster_type"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "cpu_freq_residency_summary",
  "steps": {
    "freq_residency": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_freq_residency_summary/freq_residency"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "cpu_counter_track",
    "counter"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "cpufreq"
  ],
  "skill_id": "cpu_freq_timeline",
  "steps": {
    "cpu_freq_changes": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_freq_timeline/cpu_freq_changes"
    },
    "cpu_freq_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_freq_timeline/cpu_freq_summary"
    },
    "init_cpu_topology": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "cpuidle"
  ],
  "skill_id": "cpu_idle_analysis",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.cpu.idle"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "cpu_idle_state_residency",
  "steps": {
    "idle_residency": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_idle_state_residency/idle_residency"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "sched_slice"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "runqueue_length"
  ],
  "skill_id": "cpu_load_in_range",
  "steps": {
    "cpu_utilization": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_load_in_range/cpu_utilization"
    },
    "runqueue_depth": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_load_in_range/runqueue_depth"
    },
    "thread_migrations": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_load_in_range/thread_migrations"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.cpu.frequency",
    "linux.cpu.idle"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "cpufreq"
  ],
  "skill_id": "cpu_module",
  "steps": {
    "cluster_utilization": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_module/cluster_utilization"
    },
    "cpu_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "frequency_distribution": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_module/frequency_distribution"
    },
    "frequency_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_module/frequency_overview"
    },
    "init_cpu_topology": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "throttling_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_module/throttling_events"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.cpu.utilization.process"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${process_name}",
    "${process_name}:*"
  ],
  "skill_id": "cpu_process_utilization_period",
  "steps": {
    "process_util": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_process_utilization_period/process_util"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.cpu.frequency"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*"
  ],
  "skill_id": "cpu_profiling",
  "steps": {
    "context_switches": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_profiling/context_switches"
    },
    "core_distribution": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_profiling/core_distribution"
    },
    "cpu_timeline": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_profiling/cpu_timeline"
    },
    "cpu_usage_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_profiling/cpu_usage_overview"
    },
    "init_cpu_topology": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "process_cpu_time": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_profiling/process_cpu_time"
    },
    "profiling_conclusion": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_profiling/profiling_conclusion"
    },
    "scheduling_latency": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_profiling/scheduling_latency"
    },
    "thread_cpu_time": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_profiling/thread_cpu_time"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "sched_slice"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*"
  ],
  "skill_id": "cpu_slice_analysis",
  "steps": {
    "cpu_time_by_core": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_slice_analysis/cpu_time_by_core"
    },
    "init_cpu_topology": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.cpu.frequency"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "cpu_system_context_in_range",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.cpu.utilization.thread"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${process_name}",
    "${process_name}:*"
  ],
  "skill_id": "cpu_thread_utilization_period",
  "steps": {
    "thread_util": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_thread_utilization_period/thread_util"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "cpufreq"
  ],
  "skill_id": "cpu_throttling_in_range",
  "steps": {
    "init_cpu_topology": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "limit_evidence": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_throttling_in_range/limit_evidence"
    },
    "throttle_detection": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_throttling_in_range/throttle_detection"
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.frames.per_frame_metrics"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "cpu_time_per_frame",
  "steps": {
    "cpu_time": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_time_per_frame/cpu_time"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "cpu_topology_detection",
  "steps": {
    "cluster_mapping": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_topology_detection/cluster_mapping"
    },
    "cluster_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_topology_detection/cluster_summary"
    },
    "detect_cpu_clusters": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_topology_detection/detect_cpu_clusters"
    },
    "init_cpu_topology": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "_cpu_topology",
    "cpufreq"
  ],
  "skill_id": "cpu_topology_view",
  "steps": {
    "create_topology_view": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_topology_view/create_topology_view"
    },
    "drop_existing_topology_table": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_topology_view/drop_existing_topology_table"
    },
    "drop_existing_topology_view": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_topology_view/drop_existing_topology_view"
    },
    "inspect_existing_topology_object": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_topology_view/inspect_existing_topology_object"
    },
    "read_topology": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_topology_view/read_topology"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.cpu.utilization.system"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "cpu_utilization_per_period",
  "steps": {
    "system_util": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_utilization_per_period/system_util"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.cpu.frequency",
    "intervals.intersect",
    "android.process_metadata"
  ],
  "required_tables": [
    "sched_slice",
    "thread",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "cpu_workload_attribution_in_range",
  "steps": {
    "workload_by_thread": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_workload_attribution_in_range/workload_by_thread"
    },
    "workload_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "cpu_workload_attribution_in_range/workload_summary"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "slice",
    "counter",
    "counter_track"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "*BatteryLevel*",
    "*BatteryStatus*",
    "*Idle*",
    "*MemAvailable*",
    "*MemFree*",
    "*ScreenState*",
    "*Temperature*",
    "*battery_level*",
    "*battery_status*",
    "*charging*",
    "*doze*",
    "*idle*",
    "*mem.*pressure*",
    "*psi*mem*",
    "*screen_state*",
    "*suspend*",
    "*temp*",
    "*thermal_zone*"
  ],
  "skill_id": "device_state_snapshot",
  "steps": {
    "environment_snapshot": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "device_state_snapshot/environment_snapshot"
    },
    "idle_window_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "device_state_snapshot/idle_window_summary"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "counter",
    "counter_track"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "*MemAvailable*",
    "*MemFree*",
    "*Temperature*",
    "*lowmemkiller*",
    "*mem.*pressure*",
    "*psi*mem*",
    "*temp*",
    "*thermal_zone*",
    "*tsens*",
    "cpufreq"
  ],
  "skill_id": "device_state_timeline",
  "steps": {
    "cpu_freq_transitions": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "device_state_timeline/cpu_freq_transitions"
    },
    "gpu_freq_transitions": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "device_state_timeline/gpu_freq_transitions"
    },
    "memory_pressure_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "device_state_timeline/memory_pressure_events"
    },
    "thermal_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "device_state_timeline/thermal_events"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.memory.dmabuf"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*"
  ],
  "skill_id": "dmabuf_analysis",
  "steps": {
    "buffer_lifecycle": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "dmabuf_analysis/buffer_lifecycle"
    },
    "data_check": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "dmabuf_analysis/data_check"
    },
    "dmabuf_cumulative": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "dmabuf_analysis/dmabuf_cumulative"
    },
    "dmabuf_frequency": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "dmabuf_analysis/dmabuf_frequency"
    },
    "dmabuf_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "dmabuf_analysis/dmabuf_overview"
    },
    "large_buffer_allocs": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "dmabuf_analysis/large_buffer_allocs"
    },
    "root_cause_classification": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "dmabuf_analysis/root_cause_classification"
    },
    "thread_alloc_stats": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "dmabuf_analysis/thread_alloc_stats"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "slice",
    "thread",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "*acquireBuffer*",
    "*dequeueBuffer*",
    "*latchBuffer*",
    "*presentDisplay*",
    "surfaceflinger"
  ],
  "skill_id": "fence_wait_decomposition",
  "steps": {
    "acquire_fence_wait": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "fence_wait_decomposition/acquire_fence_wait"
    },
    "fence_attribution_hint": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "fence_wait_decomposition/fence_attribution_hint"
    },
    "present_fence_timing": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "fence_wait_decomposition/present_fence_timing"
    },
    "release_fence_impact": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "fence_wait_decomposition/release_fence_impact"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "slice",
    "thread",
    "process",
    "thread_state"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*"
  ],
  "skill_id": "filesystem_module",
  "steps": {
    "database_operations": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "filesystem_module/database_operations"
    },
    "io_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "io_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "filesystem_module/io_overview"
    },
    "io_wait_state": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "filesystem_module/io_wait_state"
    },
    "main_thread_io": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "filesystem_module/main_thread_io"
    },
    "shared_prefs_operations": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "filesystem_module/shared_prefs_operations"
    },
    "slow_io_operations": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "filesystem_module/slow_io_operations"
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.frames.timeline",
    "android.frames.jank_type"
  ],
  "required_tables": [
    "actual_frame_timeline_slice"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "%BeginFrame%",
    "%Build%",
    "%Compositor%",
    "%DrawToSurface%",
    "%EntityPass%",
    "%Layout%",
    "%Paint%",
    "%Semantics%",
    "%SkGpu%",
    "*1.io*",
    "*1.raster*",
    "*1.ui*",
    "*DrawFrame*",
    "*SurfaceTexture*",
    "*queueBuffer*",
    "*updateTexImage*",
    "RenderThread",
    "VSYNC-sf"
  ],
  "skill_id": "flutter_scrolling_analysis",
  "steps": {
    "flutter_consumer_jank": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "flutter_scrolling_analysis/flutter_consumer_jank"
    },
    "flutter_frame_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "flutter_scrolling_analysis/flutter_frame_overview"
    },
    "flutter_jank_frames": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "flutter_scrolling_analysis/flutter_jank_frames"
    },
    "flutter_raster_thread_long_slices": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "flutter_scrolling_analysis/flutter_raster_thread_long_slices"
    },
    "flutter_thread_analysis": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "flutter_scrolling_analysis/flutter_thread_analysis"
    },
    "flutter_ui_thread_long_slices": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "flutter_scrolling_analysis/flutter_ui_thread_long_slices"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "*FBT*",
    "*FSTB*",
    "*GED*",
    "*PerfService*",
    "*PowerHal*",
    "*boost*",
    "*fbt*",
    "*fpsgo*",
    "*fstb*",
    "*ged*",
    "*perf_idx*",
    "*rescue*",
    "*sched_boost*"
  ],
  "skill_id": "fpsgo_analysis",
  "steps": {}
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.frames.timeline",
    "android.critical_blocking_calls"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${process_name}",
    "${process_name}:*",
    "*Binder*",
    "*RenderThread*",
    "Binder:*",
    "RenderThread"
  ],
  "skill_id": "frame_blocking_calls",
  "steps": {}
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.frames.per_frame_metrics"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "frame_overrun_summary",
  "steps": {
    "overrun_frames": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "frame_overrun_summary/overrun_frames"
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.frames.timeline"
  ],
  "required_tables": [
    "actual_frame_timeline_slice"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*"
  ],
  "skill_id": "frame_pipeline_variance",
  "steps": {}
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "actual_frame_timeline_slice",
    "slice",
    "thread",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${process_name}",
    "${process_name}:*",
    "Choreographer#doFrame%",
    "DrawFrame%",
    "RenderThread",
    "VSYNC-sf",
    "draw:%"
  ],
  "skill_id": "frame_production_gap",
  "steps": {
    "gap_list": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "frame_production_gap/gap_list"
    },
    "gap_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "frame_production_gap/gap_summary"
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.frames.per_frame_metrics"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "frame_ui_time_breakdown",
  "steps": {
    "ui_time": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "frame_ui_time_breakdown/ui_time"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "slice"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*"
  ],
  "skill_id": "futex_wait_distribution",
  "steps": {}
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.frames.timeline"
  ],
  "required_tables": [
    "actual_frame_timeline_slice",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*"
  ],
  "skill_id": "game_fps_analysis",
  "steps": {
    "detect_target_fps": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "game_fps_analysis/detect_target_fps"
    },
    "frame_interval_stats": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "game_fps_analysis/frame_interval_stats"
    },
    "jank_detection": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "game_fps_analysis/jank_detection"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "slices.with_context"
  ],
  "required_tables": [
    "slice",
    "thread_track",
    "thread",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "*Camera.Render*",
    "*Cocos*",
    "*Director::mainLoop*",
    "*FrameGameThread*",
    "*GLThread*",
    "*GameThread*",
    "*Gfx.WaitForPresent*",
    "*Main::iteration*",
    "*PlayerLoop*",
    "*RHIThread*",
    "*RenderingThread*",
    "*Tick*",
    "*Unity*",
    "*UnityGfx*",
    "*Unreal*",
    "*Update*",
    "*WaitForPresent*",
    "*cocos2d*",
    "*idle_process*",
    "*physics_process*"
  ],
  "skill_id": "game_main_loop_jank",
  "steps": {
    "engine_loop_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "game_main_loop_jank/engine_loop_summary"
    },
    "slow_engine_slices": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "game_main_loop_jank/slow_engine_slices"
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.garbage_collection"
  ],
  "required_tables": [
    "slice"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*"
  ],
  "skill_id": "gc_analysis",
  "steps": {
    "data_check": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gc_analysis/data_check"
    },
    "gc_frame_impact": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gc_analysis/gc_frame_impact"
    },
    "gc_frequency": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gc_analysis/gc_frequency"
    },
    "gc_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gc_analysis/gc_overview"
    },
    "gc_time_breakdown": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gc_analysis/gc_time_breakdown"
    },
    "long_gc_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gc_analysis/long_gc_events"
    },
    "process_gc_stats": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gc_analysis/process_gc_stats"
    },
    "root_cause_classification": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gc_analysis/root_cause_classification"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.garbage_collection"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*"
  ],
  "skill_id": "gc_events_in_range",
  "steps": {}
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "sched.thread_level_parallelism"
  ],
  "required_tables": [
    "slice",
    "thread_state",
    "sched_slice"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "global_trace_sanity_check",
  "steps": {
    "data_loss_stats": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "global_trace_sanity_check/data_loss_stats"
    },
    "runqueue_pressure": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "global_trace_sanity_check/runqueue_pressure"
    },
    "top_cpu_processes": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "global_trace_sanity_check/top_cpu_processes"
    },
    "top_d_state_threads": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "global_trace_sanity_check/top_d_state_threads"
    },
    "top_long_slices": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "top_runnable_waits": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "global_trace_sanity_check/top_runnable_waits"
    },
    "trace_diagnostics": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "global_trace_sanity_check/trace_diagnostics"
    },
    "trace_window": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "global_trace_sanity_check/trace_window"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "slices.with_context"
  ],
  "required_tables": [
    "slice",
    "thread_track",
    "thread",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "*ANativeWindow_queueBuffer*",
    "*SwapBuffers*",
    "*eglSwapBuffers*",
    "*vkQueuePresent*"
  ],
  "skill_id": "gl_standalone_swap_jank",
  "steps": {
    "slow_swap_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gl_standalone_swap_jank/slow_swap_events"
    },
    "swap_interval_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gl_standalone_swap_jank/swap_interval_summary"
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.gpu.memory",
    "intervals.intersect"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "actual_frame_timeline_slice",
    "android_gpu_memory_per_process"
  ],
  "skill_id": "gpu_analysis",
  "steps": {
    "data_check": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_analysis/data_check"
    },
    "fallback_no_gpu_data": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_analysis/fallback_no_gpu_data"
    },
    "gpu_frame_correlation": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_analysis/gpu_frame_correlation"
    },
    "gpu_freq_distribution": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_analysis/gpu_freq_distribution"
    },
    "gpu_freq_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_analysis/gpu_freq_overview"
    },
    "gpu_high_load_periods": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_analysis/gpu_high_load_periods"
    },
    "gpu_memory_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_analysis/gpu_memory_overview"
    },
    "root_cause_classification": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_analysis/root_cause_classification"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "prelude.after_eof.events"
  ],
  "required_tables": [
    "gpu_slice",
    "gpu_track"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "gpu_compute_kernel_analysis",
  "steps": {
    "data_check": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_compute_kernel_analysis/data_check"
    },
    "kernel_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_compute_kernel_analysis/kernel_summary"
    },
    "launch_configuration": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_compute_kernel_analysis/launch_configuration"
    },
    "missing_launch_args_contract": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_compute_kernel_analysis/missing_launch_args_contract"
    },
    "no_compute_contract": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_compute_kernel_analysis/no_compute_contract"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "gpu_frequency_analysis",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "gpu_freq_in_range",
  "steps": {}
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.frames.timeline"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "*Busy*",
    "*Draw*Call*",
    "*Fence*",
    "*GPU completion*",
    "*GPU*",
    "*Render*Pass*",
    "*Shader*",
    "*Util*",
    "*Waiting for GPU*",
    "*busy*",
    "*fence*",
    "*fence*signal*",
    "*freq*",
    "*gl*Draw*",
    "*gpu*",
    "*util*",
    "*vkQueue*",
    "VSYNC-sf"
  ],
  "skill_id": "gpu_metrics",
  "steps": {
    "gpu_fence_waits": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_metrics/gpu_fence_waits"
    },
    "gpu_frequency": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_metrics/gpu_frequency"
    },
    "gpu_render_time": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_metrics/gpu_render_time"
    },
    "gpu_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_metrics/gpu_summary"
    },
    "gpu_utilization": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_metrics/gpu_utilization"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "%busy%",
    "%draw%",
    "%eglSwap%",
    "%flush%",
    "%load%",
    "%swap%",
    "%util%",
    "RenderThread"
  ],
  "skill_id": "gpu_module",
  "steps": {
    "gpu_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "gpu_frequency_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_module/gpu_frequency_overview"
    },
    "gpu_utilization": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_module/gpu_utilization"
    },
    "render_thread_gpu": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_module/render_thread_gpu"
    },
    "slow_gpu_operations": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_module/slow_gpu_operations"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "gpu_power_state_analysis",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "*DrawFrame*",
    "*Fence*signal*",
    "*Flush*",
    "*GPU*",
    "*RenderThread*",
    "*dequeueBuffer*",
    "*doFrame*",
    "*eglSwap*",
    "*fence*signal*",
    "*fence*wait*",
    "*flush*",
    "*queueBuffer*",
    "*waitForFence*",
    "surfaceflinger"
  ],
  "skill_id": "gpu_render_in_range",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "intervals.overlap",
    "intervals.intersect"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "Power",
    "Temperature",
    "architecture",
    "dimension_arg_set_id",
    "machine_id",
    "ugpu"
  ],
  "skill_id": "gpu_v57_ai_diagnostics",
  "steps": {
    "data_check": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_v57_ai_diagnostics/data_check"
    },
    "dvfs_ramp_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_v57_ai_diagnostics/dvfs_ramp_events"
    },
    "frequency_residency": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_v57_ai_diagnostics/frequency_residency"
    },
    "gpu_inventory": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_v57_ai_diagnostics/gpu_inventory"
    },
    "idle_gaps": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_v57_ai_diagnostics/idle_gaps"
    },
    "no_data_contract": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_v57_ai_diagnostics/no_data_contract"
    },
    "sustained_below_target_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_v57_ai_diagnostics/sustained_below_target_events"
    },
    "timeline_occupancy": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "gpu_v57_ai_diagnostics/timeline_occupancy"
    }
  }
}

{
  "adapters": [
    {
      "id": "android_input_source",
      "selection": "data-source descriptor, build type, config, then rows",
      "version_hint": {
        "proto_input_min_api_hint": 34
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.input"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*"
  ],
  "skill_id": "input_events_in_range",
  "steps": {}
}

{
  "adapters": [
    {
      "id": "android_input_source",
      "selection": "data-source descriptor, build type, config, then rows",
      "version_hint": {
        "proto_input_min_api_hint": 34
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.input"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "%InputDispatcher%",
    "%InputReader%",
    "%deliverInputEvent%",
    "%dispatchTouchEvent%"
  ],
  "skill_id": "input_module",
  "steps": {
    "click_response_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "input_module/click_response_overview"
    },
    "input_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "input_dispatch_timing": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "input_module/input_dispatch_timing"
    },
    "slow_input_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "input_module/slow_input_events"
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    },
    {
      "id": "android_input_source",
      "selection": "data-source descriptor, build type, config, then rows",
      "version_hint": {
        "proto_input_min_api_hint": 34
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.input"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "VSYNC-app"
  ],
  "skill_id": "input_to_frame_latency",
  "steps": {
    "input_sampling_rate": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "input_to_frame_latency/input_sampling_rate"
    },
    "latency_spikes": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "input_to_frame_latency/latency_spikes"
    },
    "latency_statistics": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "input_to_frame_latency/latency_statistics"
    },
    "per_frame_latency": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "input_to_frame_latency/per_frame_latency"
    },
    "vsync_period": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "input_to_frame_latency/vsync_period"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.threads"
  ],
  "required_tables": [
    "thread_state"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*"
  ],
  "skill_id": "io_pressure",
  "steps": {
    "blocking_functions": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "io_pressure/blocking_functions"
    },
    "data_check": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "io_pressure/data_check"
    },
    "io_diagnostic": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "io_wait_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "io_pressure/io_wait_overview"
    },
    "long_io_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "io_pressure/long_io_events"
    },
    "process_io_distribution": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "io_pressure/process_io_distribution"
    },
    "root_cause_classification": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "io_pressure/root_cause_classification"
    },
    "thread_io_details": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "io_pressure/thread_io_details"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.irqs"
  ],
  "required_tables": [
    "slice"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "irq_analysis",
  "steps": {
    "data_check": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "irq_analysis/data_check"
    },
    "hard_irq_detail": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "irq_analysis/hard_irq_detail"
    },
    "irq_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "irq_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "irq_analysis/irq_overview"
    },
    "irq_timeline": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "irq_analysis/irq_timeline"
    },
    "long_irq_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "irq_analysis/long_irq_events"
    },
    "no_data_fallback": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "irq_analysis/no_data_fallback"
    },
    "root_cause_classification": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "irq_analysis/root_cause_classification"
    },
    "soft_irq_detail": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "irq_analysis/soft_irq_detail"
    },
    "top_irq_sources": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "irq_analysis/top_irq_sources"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.cpu.frequency",
    "android.binder",
    "android.slices",
    "android.monitor_contention",
    "android.garbage_collection"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "*Compile*",
    "*Draw*",
    "*DrawFrame*",
    "*Fence*",
    "*Pipeline*Create*",
    "*Shader*",
    "*compile*",
    "*dequeueBuffer*",
    "*eglSwap*",
    "*eglSwapBuffers*",
    "*fence*",
    "*postAndWait*",
    "*programCache*",
    "*shader*",
    "*syncAndDrawFrame*",
    "*syncFrameState*",
    "Choreographer#doFrame - resynced*",
    "GrGLGpu*",
    "RenderThread",
    "[0-9]*.raster",
    "[0-9]*.ui",
    "android_binder_txns",
    "android_garbage_collection_events",
    "android_monitor_contention"
  ],
  "skill_id": "jank_frame_detail",
  "steps": {
    "binder_blocking": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "binder_calls": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "jank_frame_detail/binder_calls"
    },
    "binder_table_check": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "jank_frame_detail/binder_table_check"
    },
    "choreographer_resync_markers": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "jank_frame_detail/choreographer_resync_markers"
    },
    "cpu_cluster_load": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "cpu_freq_analysis": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "jank_frame_detail/cpu_freq_analysis"
    },
    "cpu_freq_timeline": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "jank_frame_detail/cpu_freq_timeline"
    },
    "cpu_throttling": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "frame_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "gc_in_frame": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "jank_frame_detail/gc_in_frame"
    },
    "gc_table_check": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "jank_frame_detail/gc_table_check"
    },
    "gpu_freq": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "gpu_render": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "gpu_table_check": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "jank_frame_detail/gpu_table_check"
    },
    "init_cpu_topology": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "io_blocking": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "jank_frame_detail/io_blocking"
    },
    "lock_contention": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "jank_frame_detail/lock_contention"
    },
    "main_thread_slices": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "jank_frame_detail/main_thread_slices"
    },
    "monitor_contention_check": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "jank_frame_detail/monitor_contention_check"
    },
    "page_fault": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "quadrant_analysis": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "jank_frame_detail/quadrant_analysis"
    },
    "render_pipeline": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "render_thread_slices": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "jank_frame_detail/render_thread_slices"
    },
    "root_cause_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "jank_frame_detail/root_cause_summary"
    },
    "sched_latency": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "sf_composition": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "task_migration": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "vsync_alignment": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "slice",
    "thread",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "%Home%",
    "%Launcher%",
    "%home%",
    "%launcher%",
    "%lawnchair%",
    "%nexuslauncher%",
    "%trebuchet%",
    "*AIDL*",
    "*AllApps*",
    "*AppWidget*",
    "*Binder*",
    "*Choreographer#doFrame*",
    "*DrawFrame*",
    "*Drawer*",
    "*ItemClick*",
    "*RemoteViews*",
    "*Wallpaper*",
    "*Widget*",
    "*aidl*",
    "*allapps*",
    "*binder*",
    "*doFrame*",
    "*drawer*",
    "*launchApp*",
    "*onClick*",
    "*startActivity*",
    "*touch*",
    "*wallpaper*",
    "*widget*"
  ],
  "skill_id": "launcher_module",
  "steps": {
    "all_apps_drawer": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "launcher_module/all_apps_drawer"
    },
    "app_launch_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "launcher_module/app_launch_events"
    },
    "launcher_binder_calls": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "launcher_module/launcher_binder_calls"
    },
    "launcher_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "launcher_frames": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "launcher_module/launcher_frames"
    },
    "launcher_main_thread": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "launcher_module/launcher_main_thread"
    },
    "launcher_process": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "launcher_module/launcher_process"
    },
    "wallpaper_rendering": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "launcher_module/wallpaper_rendering"
    },
    "widget_activities": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "launcher_module/widget_activities"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.irqs"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "linux_irq_summary",
  "steps": {
    "irq_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "linux_irq_summary/irq_summary"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.perf.counters"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "linux_perf_counter_hotspots",
  "steps": {
    "perf_counter_hotspots": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "linux_perf_counter_hotspots/perf_counter_hotspots"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.memory.process"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "linux_process_rss_swap_timeline",
  "steps": {
    "rss_swap_peaks": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "linux_process_rss_swap_timeline/rss_swap_peaks"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "sched.thread_level_parallelism"
  ],
  "required_tables": [
    "thread_state"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "linux_runqueue_depth_timeline",
  "steps": {
    "runqueue_pressure_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "linux_runqueue_depth_timeline/runqueue_pressure_summary"
    },
    "runqueue_pressure_windows": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "linux_runqueue_depth_timeline/runqueue_pressure_windows"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "sched.latency"
  ],
  "required_tables": [
    "thread",
    "process",
    "thread_state"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "linux_sched_latency_distribution",
  "steps": {
    "sched_latency_distribution": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "linux_sched_latency_distribution/sched_latency_distribution"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.systemd_journald"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "linux_systemd_journald_analysis",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.memory.lmk",
    "linux.memory.general"
  ],
  "required_tables": [
    "android_lmk_events"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "mem.available",
    "mem.free"
  ],
  "skill_id": "lmk_analysis",
  "steps": {
    "data_check": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lmk_analysis/data_check"
    },
    "high_priority_kills": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lmk_analysis/high_priority_kills"
    },
    "lmk_frequency": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lmk_analysis/lmk_frequency"
    },
    "lmk_memory_context": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lmk_analysis/lmk_memory_context"
    },
    "lmk_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lmk_analysis/lmk_overview"
    },
    "lmk_timeline": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lmk_analysis/lmk_timeline"
    },
    "process_restart_after_lmk": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lmk_analysis/process_restart_after_lmk"
    },
    "root_cause_classification": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lmk_analysis/root_cause_classification"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.memory.lmk"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${process_name}",
    "${process_name}:*"
  ],
  "skill_id": "lmk_kill_attribution",
  "steps": {
    "lmk_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lmk_kill_attribution/lmk_events"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.binder",
    "android.monitor_contention",
    "slices.with_context"
  ],
  "required_tables": [
    "thread_state",
    "thread",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "lock_binder_wait",
  "steps": {
    "main_thread_blocking_chain": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "monitor_lock_contention": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "sync_binder_blocking": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.monitor_contention",
    "android.lock_held",
    "slices.with_context"
  ],
  "required_tables": [
    "thread_state"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${process_name}",
    "${process_name}:*",
    "*_lock_held",
    "*monitor*",
    "*mutex*",
    "Lock contention*(owner tid: *)*",
    "android_lock_held"
  ],
  "skill_id": "lock_contention_analysis",
  "steps": {
    "blocking_functions": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lock_contention_analysis/blocking_functions"
    },
    "blocking_thread_state": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lock_contention_analysis/blocking_thread_state"
    },
    "contention_binder_correlation": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lock_contention_analysis/contention_binder_correlation"
    },
    "contention_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lock_contention_analysis/contention_overview"
    },
    "data_check": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lock_contention_analysis/data_check"
    },
    "fallback_no_data": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lock_contention_analysis/fallback_no_data"
    },
    "hot_locks": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lock_contention_analysis/hot_locks"
    },
    "lock_chain_analysis": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lock_contention_analysis/lock_chain_analysis"
    },
    "lock_held_capability": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lock_contention_analysis/lock_held_capability"
    },
    "lock_held_long_holds": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lock_contention_analysis/lock_held_long_holds"
    },
    "lock_held_owner_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lock_contention_analysis/lock_held_owner_summary"
    },
    "main_thread_contentions": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lock_contention_analysis/main_thread_contentions"
    },
    "owner_contention_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lock_contention_analysis/owner_contention_events"
    },
    "root_cause_classification": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lock_contention_analysis/root_cause_classification"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.monitor_contention",
    "slices.with_context"
  ],
  "required_tables": [
    "thread_state",
    "android_monitor_contention"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "*monitor*",
    "*mutex*",
    "Lock contention*(owner tid: *)*"
  ],
  "skill_id": "lock_contention_in_range",
  "steps": {
    "futex_waits": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lock_contention_in_range/futex_waits"
    },
    "lock_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lock_contention_in_range/lock_summary"
    },
    "monitor_contentions": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lock_contention_in_range/monitor_contentions"
    },
    "owner_contentions": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lock_contention_in_range/owner_contentions"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "slice",
    "thread",
    "process",
    "thread_state"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "%Binder%",
    "*Lock*",
    "*LockContention*",
    "*Monitor*",
    "*Mutex*",
    "*acquired*",
    "*contention*",
    "*futex*",
    "*holding*lock*",
    "*lock*",
    "*lock*held*",
    "*monitor*",
    "*mutex*",
    "*synchronized*",
    "*wait*"
  ],
  "skill_id": "lock_contention_module",
  "steps": {
    "binder_thread_locks": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lock_contention_module/binder_thread_locks"
    },
    "blocked_threads": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lock_contention_module/blocked_threads"
    },
    "lock_contention_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lock_contention_module/lock_contention_overview"
    },
    "lock_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "long_lock_holds": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lock_contention_module/long_lock_holds"
    },
    "main_thread_locks": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lock_contention_module/main_thread_locks"
    },
    "monitor_contention": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lock_contention_module/monitor_contention"
    },
    "thread_contention_pairs": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "lock_contention_module/thread_contention_pairs"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "android_logs"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "logcat_analysis",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "slice",
    "track",
    "thread_track",
    "thread",
    "process",
    "process_track"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "longest_process_slices",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*"
  ],
  "skill_id": "main_thread_file_io_in_range",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "slice",
    "thread_track",
    "thread_state",
    "thread",
    "process",
    "trace_bounds"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "main_thread_frame_work",
  "steps": {
    "main_thread_work_cadence": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "main_thread_frame_work/main_thread_work_cadence"
    },
    "main_thread_work_sources": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "main_thread_frame_work/main_thread_work_sources"
    },
    "main_thread_work_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "main_thread_frame_work/main_thread_work_summary"
    },
    "main_thread_work_tasks": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "main_thread_frame_work/main_thread_work_tasks"
    },
    "system_context_window": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "main_thread_frame_work/system_context_window"
    },
    "system_cpu_context": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "system_task_handoffs": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "system_task_summary": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.slices"
  ],
  "required_tables": [
    "slice",
    "thread_track",
    "thread",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "*Handler: *"
  ],
  "skill_id": "main_thread_handler_callback_slices",
  "steps": {
    "callback_slices": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "fixtures": [
            "startup-heavy-api36",
            "startup-heavy-api36"
          ],
          "status": "verified"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "main_thread_handler_callback_slices/callback_slices"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}:*"
  ],
  "skill_id": "main_thread_sched_latency_in_range",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package|}",
    "${package|}:*"
  ],
  "skill_id": "main_thread_slices_in_range",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package|}",
    "${package|}:*"
  ],
  "skill_id": "main_thread_states_in_range",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.gpu.mali_power_state"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "mali_gpu_power_state",
  "steps": {
    "mali_state": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "mali_gpu_power_state/mali_state"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "slices.with_context"
  ],
  "required_tables": [
    "slice",
    "thread_track",
    "thread",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "*C2*",
    "*CCodec*",
    "*Codec2*",
    "*MediaCodec*",
    "*OMX*",
    "*dequeueInputBuffer*",
    "*dequeueOutputBuffer*",
    "*queueInputBuffer*",
    "*releaseOutputBuffer*"
  ],
  "skill_id": "media_codec_activity",
  "steps": {
    "codec_activity_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "media_codec_activity/codec_activity_summary"
    },
    "slow_codec_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "media_codec_activity/slow_codec_events"
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*"
  ],
  "skill_id": "memory_analysis",
  "steps": {
    "bitmap_memory": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "gc_frame_impact": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "memory_analysis/gc_frame_impact"
    },
    "gc_interval_analysis": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "memory_analysis/gc_interval_analysis"
    },
    "gc_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "memory_analysis/gc_overview"
    },
    "gc_stats": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "memory_analysis/gc_stats"
    },
    "gc_thread_state": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "memory_analysis/gc_thread_state"
    },
    "get_process": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "memory_analysis/get_process"
    },
    "get_vsync_period": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "heap_graph_leak_candidates": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "heap_graph_summary": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "lmk_events": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "long_gc_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "memory_analysis/long_gc_events"
    },
    "main_thread_gc": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "memory_analysis/main_thread_gc"
    },
    "memory_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "memory_growth_summary": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "native_heap_hotspots": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "rss_swap_peaks": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.memory.process"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "memory_growth_detector",
  "steps": {
    "memory_growth": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "memory_growth_detector/memory_growth"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "counter",
    "counter_track"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "%Buffers%",
    "%Cached%",
    "%Mem%",
    "%MemAvailable%",
    "%MemFree%",
    "%Memory%",
    "%RSS%",
    "%SwapFree%",
    "%heap%",
    "%mem%",
    "%memory%",
    "%rss%",
    "*Alloc*",
    "*LMK*",
    "*OOM*",
    "*PSI*",
    "*alloc*",
    "*dmabuf*",
    "*fault*",
    "*gpu*mem*",
    "*graphics*",
    "*ion*",
    "*kill*memory*",
    "*lmk*",
    "*lowmemory*",
    "*malloc*",
    "*mmap*",
    "*oom*",
    "*page*fault*",
    "*pgfault*",
    "*pressure*",
    "*psi*"
  ],
  "skill_id": "memory_module",
  "steps": {
    "allocation_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "memory_module/allocation_events"
    },
    "dmabuf_usage": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "memory_module/dmabuf_usage"
    },
    "lmk_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "memory_module/lmk_events"
    },
    "memory_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "memory_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "memory_module/memory_overview"
    },
    "memory_psi": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "memory_module/memory_psi"
    },
    "memory_timeline": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "memory_module/memory_timeline"
    },
    "page_fault_analysis": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "memory_module/page_fault_analysis"
    },
    "process_memory": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "memory_module/process_memory"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "%alloc_pages%",
    "%compact%",
    "%direct_reclaim%",
    "%lmkd%",
    "%lowmemory%",
    "%memory_pressure%",
    "%oom_adj%",
    "%page_alloc%",
    "%reclaim%alloc%",
    "kswapd%",
    "mem.%psi%",
    "mm_filemap_add_to_page_cache",
    "mm_filemap_delete_from_page_cache"
  ],
  "skill_id": "memory_pressure_in_range",
  "steps": {
    "memory_pressure_analysis": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "memory_pressure_in_range/memory_pressure_analysis"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.memory.high_watermark"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${process_name}",
    "${process_name}:*"
  ],
  "skill_id": "memory_rss_high_watermark",
  "steps": {
    "rss_peaks": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "memory_rss_high_watermark/rss_peaks"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.power_rails",
    "android.network_packets"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "modem_network_correlation_summary",
  "steps": {
    "modem_network_correlation": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "modem_network_correlation_summary/modem_network_correlation"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "multi_trace_result_comparison",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "callstacks.stack_profile"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "/[[]anon_shmem:dalvik-jit-code-cache]*",
    "/apex/com.android.art/*",
    "/apex/com.android.runtime/*",
    "/system/lib*/libart.so",
    "/system/lib*/libc++.so",
    "/system/lib*/libc.so",
    "heapprofd*",
    "heapprofd_malformed_packet"
  ],
  "skill_id": "native_heap_breakdown",
  "steps": {
    "heap_profile_inventory": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "native_heap_breakdown/heap_profile_inventory"
    },
    "native_heap_hotspots": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "native_heap_breakdown/native_heap_hotspots"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.binder"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "${target_process.data[0].process_name}",
    "*ActivityTransition*",
    "*Binder*",
    "*Choreographer#doFrame*",
    "*Fragment*onCreate*",
    "*Fragment*onResume*",
    "*FragmentTransaction*",
    "*GC*",
    "*LayoutInflater*",
    "*SQL*",
    "*SharedElement*",
    "*SharedPreferences*",
    "*Transition*",
    "*activityResume*",
    "*activityStart*",
    "*binder*",
    "*commit*Fragment*",
    "*database*",
    "*http*",
    "*inflate*",
    "*network*",
    "*okhttp*",
    "*performCreate*",
    "*performCreate*Fragment*",
    "*performDestroy*",
    "*performPause*",
    "*performResume*",
    "*performStart*",
    "*performStop*",
    "*setContentView*",
    "*sqlite*",
    "*windowAnimation*"
  ],
  "skill_id": "navigation_analysis",
  "steps": {
    "check_lifecycle_data": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "navigation_analysis/check_lifecycle_data"
    },
    "first_frame_render": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "navigation_analysis/first_frame_render"
    },
    "fragment_transactions": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "navigation_analysis/fragment_transactions"
    },
    "get_process": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "navigation_analysis/get_process"
    },
    "layout_inflation": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "navigation_analysis/layout_inflation"
    },
    "lifecycle_event_detail": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "navigation_analysis/lifecycle_event_detail"
    },
    "lifecycle_phase_breakdown": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "navigation_analysis/lifecycle_phase_breakdown"
    },
    "navigation_binder_calls": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "navigation_analysis/navigation_binder_calls"
    },
    "navigation_blocking_ops": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "navigation_analysis/navigation_blocking_ops"
    },
    "navigation_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "navigation_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "navigation_analysis/navigation_overview"
    },
    "no_data_fallback": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "navigation_analysis/no_data_fallback"
    },
    "transition_animations": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "navigation_analysis/transition_animations"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.network_packets"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "*Connect*",
    "*DNS*",
    "*Http*",
    "*Network*",
    "*Socket*",
    "*connect*",
    "*dns*",
    "*http*",
    "*network*",
    "*socket*"
  ],
  "skill_id": "network_analysis",
  "steps": {
    "app_traffic_ranking": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "network_analysis/app_traffic_ranking"
    },
    "check_network_data": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "network_analysis/check_network_data"
    },
    "check_network_slices": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "network_analysis/check_network_slices"
    },
    "evidence_scope": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "network_analysis/evidence_scope"
    },
    "fallback_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "large_transfers": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "network_analysis/large_transfers"
    },
    "network_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "network_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "network_analysis/network_overview"
    },
    "network_power_cost": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "network_analysis/network_power_cost"
    },
    "network_slice_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "network_analysis/network_slice_overview"
    },
    "port_analysis": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "network_analysis/port_analysis"
    },
    "traffic_by_interface": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "network_analysis/traffic_by_interface"
    },
    "traffic_timeline": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "network_analysis/traffic_timeline"
    },
    "transport_distribution": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "network_analysis/transport_distribution"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.oom_adjuster"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${process_name}",
    "${process_name}:*"
  ],
  "skill_id": "oom_adjuster_score_timeline",
  "steps": {
    "oom_intervals": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "oom_adjuster_score_timeline/oom_intervals"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "%Binder%",
    "RenderThread"
  ],
  "skill_id": "page_fault_in_range",
  "steps": {}
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "slices.with_context",
    "android.frames.timeline"
  ],
  "required_tables": [
    "slice",
    "thread_track",
    "thread",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "*AChoreographer*",
    "*ASurfaceTransaction*",
    "*BLASTBufferQueue*",
    "*Choreographer#doFrame*",
    "*FEngineLoop*",
    "*MainLoop*",
    "*PlayerLoop*",
    "*Swappy*",
    "*SwappyVk_*",
    "*Vulkan*",
    "*applyTransaction*",
    "*eglSwapBuffers*",
    "*lockCanvas*",
    "*processCaptureRequest*",
    "*processCaptureResult*",
    "*queueBuffer*",
    "*releaseOutputBuffer*",
    "*setFrameRate*",
    "*setFrameRateCategory*",
    "*unlockCanvasAndPost*",
    "*updateTexImage*",
    "*vkQueuePresentKHR*",
    "1.io",
    "1.raster",
    "1.ui",
    "Compositor",
    "CompositorTileWorker*",
    "CrRendererMain*",
    "DrawFrame*",
    "GLThread*",
    "GameThread",
    "GodotMain*",
    "RHIThread",
    "RenderThread",
    "UnityGfx*",
    "UnityMain*",
    "VizCompositorThread*",
    "VkQueue*",
    "main",
    "mqt_js*",
    "mqt_native*"
  ],
  "skill_id": "pipeline_4feature_scoring",
  "steps": {
    "bufferqueue_path": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "pipeline_4feature_scoring/bufferqueue_path"
    },
    "extra_rhythm": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "pipeline_4feature_scoring/extra_rhythm"
    },
    "layer_signature": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "pipeline_4feature_scoring/layer_signature"
    },
    "producer_thread_signature": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "pipeline_4feature_scoring/producer_thread_signature"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_android_pip_freeform",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_android_view_mixed",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_android_view_multi_window",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_android_view_software",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_android_view_standard_blast",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_android_view_standard_legacy",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_angle_gles_vulkan",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_camera_pipeline",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_chrome_browser_viz",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_compose_standard",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_flutter_surfaceview_impeller",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_flutter_surfaceview_skia",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_flutter_textureview",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_game_engine",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_hardware_buffer_renderer",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_imagereader_pipeline",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "%HWC%",
    "%surfaceflinger%",
    "RenderThread",
    "system_server"
  ],
  "skill_id": "pipeline_key_slices_overlay",
  "steps": {
    "pipeline_key_slices_overlay": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "pipeline_key_slices_overlay/pipeline_key_slices_overlay"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_opengl_es",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_rn_new_arch",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_rn_old_arch",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_rn_skia",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_software_compositing",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_surfaceview_blast",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_surface_control_api",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_textureview_standard",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_variable_refresh_rate",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_video_overlay_hwc",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_vulkan_native",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_webview_gl_functor",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_webview_surfaceview_wrapper",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_webview_surface_control",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "29": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "30": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "31": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "32": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "33": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "34": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "35": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "36": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    },
    "37": {
      "reason": "Metadata/reference Skill has no trace execution",
      "status": "not_applicable"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "pipeline_webview_textureview_custom",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.power_rails",
    "wattson.aggregation",
    "android.battery",
    "android.kernel_wakelocks",
    "android.wakeups",
    "android.screen_state",
    "android.network_packets",
    "linux.cpu.idle"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "power_consumption_overview",
  "steps": {
    "battery_charge": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "battery_drain_rate": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "cpu_freq_residency": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "dvfs": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "gpu_work_period": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "hardware_rails": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "modem_network": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "screen_off_cpu": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "suspend_wakeup": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "wakelocks": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "wakeup_frequency": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "wattson_rails": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "wattson_threads": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "counter",
    "counter_track"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "*Battery*",
    "*C-state*",
    "*Doze*",
    "*Idle*",
    "*Power*",
    "*PowerManager*",
    "*RESUME*",
    "*Resume*",
    "*SUSPEND*",
    "*Suspend*",
    "*WAKE_LOCK*",
    "*Wakelock*",
    "*acquire*wake*",
    "*alarm*",
    "*battery*",
    "*battery*saver*",
    "*cpuidle*",
    "*current*",
    "*doze*",
    "*energy*",
    "*idle*",
    "*irq*wake*",
    "*performance*mode*",
    "*power*",
    "*power*mode*",
    "*resume*",
    "*sleep*",
    "*standby*",
    "*suspend*",
    "*voltage*",
    "*wake_source*",
    "*wakelock*",
    "*wakeup*"
  ],
  "skill_id": "power_module",
  "steps": {
    "cpu_idle_states": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "power_module/cpu_idle_states"
    },
    "long_wakelocks": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "power_module/long_wakelocks"
    },
    "power_counters": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "power_module/power_counters"
    },
    "power_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "power_mode_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "power_module/power_mode_events"
    },
    "suspend_resume": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "power_module/suspend_resume"
    },
    "wakelock_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "power_module/wakelock_overview"
    },
    "wakeup_sources": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "power_module/wakeup_sources"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.power_rails"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "power_rails_energy_breakdown",
  "steps": {
    "rail_energy": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "power_rails_energy_breakdown/rail_energy"
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.frames.timeline"
  ],
  "required_tables": [
    "slice"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "*GPU completion*",
    "*PresentFence*",
    "*Waiting for GPU*",
    "*present*fence*",
    "*waiting for GPU*",
    "VSYNC-sf"
  ],
  "skill_id": "present_fence_timing",
  "steps": {
    "present_fence_stats": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "present_fence_timing/present_fence_stats"
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    },
    {
      "id": "android_input_source",
      "selection": "data-source descriptor, build type, config, then rows",
      "version_hint": {
        "proto_input_min_api_hint": 34
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.process_metadata",
    "android.frames.timeline",
    "android.oom_adjuster",
    "android.battery_stats"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "/apex/*",
    "/odm/bin/*",
    "/system/bin/*",
    "/system_ext/bin/*",
    "/vendor/bin/*",
    "Cr*Main",
    "[0-9]*.raster",
    "[0-9]*.ui",
    "battery_stats.top",
    "com.android.inputmethod*",
    "com.android.launcher*",
    "com.android.systemui*",
    "com.google.android.apps.nexuslauncher*",
    "com.google.android.inputmethod*",
    "com.huawei.android.launcher*",
    "com.miui.home*",
    "com.oppo.launcher*",
    "com.sec.android.app.launcher*",
    "com.vivo.launcher*"
  ],
  "skill_id": "process_identity_resolver",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "slice",
    "thread_track",
    "thread",
    "process",
    "thread_state"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "%",
    "GPU completion",
    "RenderThread",
    "[0-9]*.raster",
    "[0-9]*.ui"
  ],
  "skill_id": "process_slice_cpu_hotspots",
  "steps": {}
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.network_packets"
  ],
  "required_tables": [
    "thread_state",
    "thread",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*"
  ],
  "skill_id": "process_thread_wait_sources_in_range",
  "steps": {
    "network_packet_correlation": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "process_thread_wait_sources_in_range/network_packet_correlation"
    },
    "packet_check": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "process_thread_wait_sources_in_range/packet_check"
    },
    "role_state_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "process_thread_wait_sources_in_range/role_state_summary"
    },
    "top_waits": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "process_thread_wait_sources_in_range/top_waits"
    },
    "wait_class_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "process_thread_wait_sources_in_range/wait_class_summary"
    },
    "wake_evidence_scope": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "process_thread_wait_sources_in_range/wake_evidence_scope"
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    },
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "slices.with_context",
    "android.frames.timeline"
  ],
  "required_tables": [
    "slice",
    "thread_track",
    "thread",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "*BLASTBufferQueue*",
    "*Choreographer#doFrame*",
    "*Chrome*",
    "*Engine::BeginFrame*",
    "*EntityPass*",
    "*FramePacing*",
    "*FrameTimeline*",
    "*Rasterizer::DrawToSurfaces*",
    "*Swappy*",
    "*applyTransaction*",
    "*dequeueBuffer*",
    "*eglSwapBuffers*",
    "*lockCanvas*",
    "*queueBuffer*",
    "*unlockCanvasAndPost*",
    "*updateTexImage*",
    "*vkQueuePresentKHR*",
    "CrRendererMain*",
    "DrawFrame*",
    "GameThread*",
    "GodotMain*",
    "RHIThread*",
    "RenderThread",
    "UnityMain*",
    "VizCompositor",
    "VizCompositor*",
    "VizCompositorThread",
    "VizCompositorThread*",
    "main",
    "surfaceflinger"
  ],
  "skill_id": "rendering_pipeline_detection",
  "steps": {
    "active_rendering_processes": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "fixtures": [
            "flutter-texture-api35"
          ],
          "status": "verified"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "rendering_pipeline_detection/active_rendering_processes"
    },
    "bufferqueue_path_signals": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "fixtures": [
            "flutter-texture-api35"
          ],
          "status": "verified"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "rendering_pipeline_detection/bufferqueue_path_signals"
    },
    "determine_pipeline": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "rendering_pipeline_detection/determine_pipeline"
    },
    "extra_rhythm_signals": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "rendering_pipeline_detection/extra_rhythm_signals"
    },
    "layer_signals": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "rendering_pipeline_detection/layer_signals"
    },
    "score_pipelines": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "rendering_pipeline_detection/score_pipelines"
    },
    "subvariants": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "rendering_pipeline_detection/subvariants"
    },
    "trace_requirements": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "rendering_pipeline_detection/trace_requirements"
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.frames.timeline"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "render_pipeline_latency",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "slices.with_context"
  ],
  "required_tables": [
    "slice",
    "thread_track",
    "thread",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "RenderThread"
  ],
  "skill_id": "render_thread_slices",
  "steps": {
    "render_slices": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "render_thread_slices/render_slices"
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.frames.timeline",
    "slices.with_context"
  ],
  "required_tables": [
    "actual_frame_timeline_slice",
    "slice",
    "thread_track",
    "thread",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "*BatchedBridge*",
    "*JS*",
    "*RCTEventEmitter*",
    "*ReactChoreographer*",
    "*UIManager*",
    "*callFunctionReturnFlushedQueue*",
    "*dispatchViewUpdates*",
    "*mqt_js*",
    "*mqt_native_modules*"
  ],
  "skill_id": "rn_bridge_to_frame_jank",
  "steps": {
    "rn_bridge_frame_overlap": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "rn_bridge_to_frame_jank/rn_bridge_frame_overlap"
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.frames.timeline",
    "slices.with_context"
  ],
  "required_tables": [
    "actual_frame_timeline_slice",
    "slice",
    "thread_track",
    "thread",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "*Fabric*",
    "*JSI*",
    "*MountItem*",
    "*Reanimated*",
    "*ShadowTree*",
    "*SurfaceMountingManager*",
    "*TurboModule*",
    "*executeMount*",
    "*mqt_native_modules*"
  ],
  "skill_id": "rn_fabric_render_jank",
  "steps": {
    "fabric_frame_overlap": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "rn_fabric_render_jank/fabric_frame_overlap"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.screen_state",
    "android.battery.charging_states"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "scene_device_state_changes",
  "steps": {
    "state_intervals": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scene_device_state_changes/state_intervals"
    },
    "state_sources": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scene_device_state_changes/state_sources"
    }
  }
}

{
  "adapters": [
    {
      "branches": [
        "api<=28",
        "api29-32",
        "api>=33"
      ],
      "id": "official_android_startup_tags",
      "source": "perfetto stdlib android/startup/startups.sql"
    },
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    },
    {
      "id": "android_input_source",
      "selection": "data-source descriptor, build type, config, then rows",
      "version_hint": {
        "proto_input_min_api_hint": 34
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.input",
    "android.binder",
    "android.screen_state",
    "android.battery_stats",
    "android.startup.startups",
    "android.frames.timeline",
    "android.anrs"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "% %",
    "%:%",
    "%MemFree%",
    "%SwapFree%",
    "%battery%charge%",
    "%battery%plugged%",
    "%charge%",
    "%current%",
    "%mem%pressure%",
    "%plugged%",
    "%thermal_zone%",
    "%voltage%",
    "*.*",
    "*AlarmManager*",
    "*AppTransition*",
    "*AppTransitionReady*",
    "*BackGesture*",
    "*BackPanel*",
    "*BroadcastQueue*",
    "*InputMethodManager*hide*",
    "*InputMethodManager*show*",
    "*InputMethodService*hide*",
    "*InputMethodService*show*",
    "*RecentsAnimation*",
    "*Shell transition*",
    "*SwipeToHome*",
    "*activityDestroy*",
    "*activityPause*",
    "*activityResume*",
    "*activityStart*",
    "*activityStop*",
    "*broadcastReceive*",
    "*closeAnimation*",
    "*goToHome*",
    "*hideSoftInput*",
    "*launcher*",
    "*launcher*goHome*",
    "*onBackGesture*",
    "*openAnimation*",
    "*performCreate*",
    "*performDestroy*",
    "*performPause*",
    "*performResume*",
    "*performStop*",
    "*show*",
    "*showSoftInput*",
    "*startRecentsActivity*",
    "*startingWindow*",
    "RV Scroll",
    "batt.%",
    "battery_stats.top",
    "bindApplication",
    "com.android.systemui*",
    "com.android.wm.shell*",
    "cpufreq",
    "oom_score_adj",
    "system_server"
  ],
  "skill_id": "scene_reconstruction",
  "steps": {
    "activity_lifecycle": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scene_reconstruction/activity_lifecycle"
    },
    "anr_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scene_reconstruction/anr_events"
    },
    "app_launches": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scene_reconstruction/app_launches"
    },
    "app_state_tracking": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scene_reconstruction/app_state_tracking"
    },
    "broadcast_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scene_reconstruction/broadcast_events"
    },
    "clean_timeline": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scene_reconstruction/clean_timeline"
    },
    "cross_process_interactions": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scene_reconstruction/cross_process_interactions"
    },
    "device_state": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scene_reconstruction/device_state"
    },
    "gesture_navigation": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scene_reconstruction/gesture_navigation"
    },
    "idle_periods": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scene_reconstruction/idle_periods"
    },
    "ime_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scene_reconstruction/ime_events"
    },
    "inertial_scrolls": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scene_reconstruction/inertial_scrolls"
    },
    "input_coverage": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scene_reconstruction/input_coverage"
    },
    "jank_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scene_reconstruction/jank_events"
    },
    "merged_timeline": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scene_reconstruction/merged_timeline"
    },
    "navigation_keys": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scene_reconstruction/navigation_keys"
    },
    "operation_chain": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scene_reconstruction/operation_chain"
    },
    "screen_state_changes": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scene_reconstruction/screen_state_changes"
    },
    "scroll_initiation": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scene_reconstruction/scroll_initiation"
    },
    "system_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scene_reconstruction/system_events"
    },
    "table_availability": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scene_reconstruction/table_availability"
    },
    "top_app_changes": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scene_reconstruction/top_app_changes"
    },
    "trace_time_range": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scene_reconstruction/trace_time_range"
    },
    "user_gestures": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scene_reconstruction/user_gestures"
    },
    "window_transitions": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scene_reconstruction/window_transitions"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "slice",
    "track",
    "thread_track",
    "thread",
    "process_track",
    "process",
    "trace_bounds"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "scene_response_markers",
  "steps": {
    "response_markers": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scene_response_markers/response_markers"
    },
    "response_sources": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scene_response_markers/response_sources"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.cpu.frequency"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}:*"
  ],
  "skill_id": "scheduler_module",
  "steps": {
    "core_distribution": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scheduler_module/core_distribution"
    },
    "cpu_frequency": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scheduler_module/cpu_frequency"
    },
    "init_cpu_topology": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "runnable_analysis": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scheduler_module/runnable_analysis"
    },
    "scheduling_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "sched_slice"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}:*"
  ],
  "skill_id": "scheduling_analysis",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}:*"
  ],
  "skill_id": "sched_latency_in_range",
  "steps": {}
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.screen_state"
  ],
  "required_tables": [
    "sched",
    "thread",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "screen_off_background_cpu_attribution",
  "steps": {
    "screen_off_cpu": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "screen_off_background_cpu_attribution/screen_off_cpu"
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    },
    {
      "id": "android_input_source",
      "selection": "data-source descriptor, build type, config, then rows",
      "version_hint": {
        "proto_input_min_api_hint": 34
      }
    },
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.input",
    "android.frames.timeline",
    "android.frames.jank_type",
    "android.binder",
    "android.garbage_collection",
    "android.monitor_contention"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "*.raster",
    "*.ui",
    "*CodecLooper*",
    "*Compile*",
    "*DrawFrame*",
    "*Fence*",
    "*InputConsumer*",
    "*MediaCodec*",
    "*NuPlayer*",
    "*QueuedWork*",
    "*RV Prefetch*",
    "*RecyclerView*Prefetch*",
    "*SQLiteDatabase*",
    "*Shader*",
    "*SharedPreferences*",
    "*VideoDecoder*",
    "*commit*SharedPref*",
    "*compile*",
    "*deliverInputEvent*",
    "*dequeueBuffer*",
    "*dispatchTouchEvent*",
    "*eglSwapBuffers*",
    "*fence*",
    "*fsync*",
    "*getSharedPreferences*",
    "*onInterceptTouchEvent*",
    "*onOutputBufferAvailable*",
    "*onTouchEvent*",
    "*openFile*",
    "*postAndWait*",
    "*processInputEventForCompatibility*",
    "*queueVideoBuffer*",
    "*shader*",
    "*sqlite*",
    "*syncAndDrawFrame*",
    "*syncFrameState*",
    "*waitToFinish*",
    "Choreographer#doFrame%",
    "DrawFrame%",
    "Framework::BeginFrame%",
    "PlayerLoop%",
    "RenderThread",
    "VSYNC-sf",
    "[0-9]*",
    "[0-9]*.raster",
    "[0-9]*.ui",
    "actual_frame_timeline_slice",
    "cpufreq",
    "frame_slice"
  ],
  "skill_id": "scrolling_analysis",
  "steps": {
    "batch_frame_root_cause": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scrolling_analysis/batch_frame_root_cause"
    },
    "buffer_tx_coverage_probe": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scrolling_analysis/buffer_tx_coverage_probe"
    },
    "buffer_tx_performance_fallback": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scrolling_analysis/buffer_tx_performance_fallback"
    },
    "expert_analysis_window": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scrolling_analysis/expert_analysis_window"
    },
    "fallback_no_frame_timeline": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scrolling_analysis/fallback_no_frame_timeline"
    },
    "frame_timeline_check": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "fixtures": [
            "scroll-aosp-api35"
          ],
          "status": "verified"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scrolling_analysis/frame_timeline_check"
    },
    "frame_timeline_population": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scrolling_analysis/frame_timeline_population"
    },
    "frame_variance_probe": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "get_app_jank_frames": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scrolling_analysis/get_app_jank_frames"
    },
    "global_context_flags": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scrolling_analysis/global_context_flags"
    },
    "init_cpu_topology": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "input_data_check": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scrolling_analysis/input_data_check"
    },
    "input_data_fallback_view": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scrolling_analysis/input_data_fallback_view"
    },
    "input_latency_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scrolling_analysis/input_latency_summary"
    },
    "jank_type_stats": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scrolling_analysis/jank_type_stats"
    },
    "main_thread_work_cadence": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scrolling_analysis/main_thread_work_cadence"
    },
    "main_thread_work_sources": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scrolling_analysis/main_thread_work_sources"
    },
    "main_thread_work_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scrolling_analysis/main_thread_work_summary"
    },
    "main_thread_work_tasks": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scrolling_analysis/main_thread_work_tasks"
    },
    "performance_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scrolling_analysis/performance_summary"
    },
    "root_cause_classification": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scrolling_analysis/root_cause_classification"
    },
    "scroll_sessions": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scrolling_analysis/scroll_sessions"
    },
    "session_cpu_freq": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scrolling_analysis/session_cpu_freq"
    },
    "session_jank": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scrolling_analysis/session_jank"
    },
    "session_quadrant_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scrolling_analysis/session_quadrant_summary"
    },
    "session_stats_batch": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scrolling_analysis/session_stats_batch"
    },
    "session_thread_core_affinity": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scrolling_analysis/session_thread_core_affinity"
    },
    "smoothness_basis": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scrolling_analysis/smoothness_basis"
    },
    "system_context_window": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scrolling_analysis/system_context_window"
    },
    "system_cpu_context": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "system_task_handoffs": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "system_task_summary": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "vsync_config": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scrolling_analysis/vsync_config"
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    },
    {
      "id": "android_input_source",
      "selection": "data-source descriptor, build type, config, then rows",
      "version_hint": {
        "proto_input_min_api_hint": 34
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.input"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*"
  ],
  "skill_id": "scroll_response_latency",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "*Choreographer#doFrame*",
    "*DrawFrame*",
    "*doFrame*"
  ],
  "skill_id": "scroll_session_analysis",
  "steps": {
    "analyze_janky_frames": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "fling_phase_stats": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scroll_session_analysis/fling_phase_stats"
    },
    "full_session_stats": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scroll_session_analysis/full_session_stats"
    },
    "identify_janky_frames": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scroll_session_analysis/identify_janky_frames"
    },
    "session_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "system_context_window": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scroll_session_analysis/system_context_window"
    },
    "system_cpu_context": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "system_task_handoffs": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "system_task_summary": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "touch_phase_stats": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "scroll_session_analysis/touch_phase_stats"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.cpu.frequency"
  ],
  "required_tables": [
    "thread_state",
    "thread",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package|}:*"
  ],
  "skill_id": "selection_range_cpu_sched_summary",
  "steps": {
    "cpu_freq_by_core": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "selection_range_cpu_sched_summary/cpu_freq_by_core"
    },
    "cpu_freq_distribution": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "selection_range_cpu_sched_summary/cpu_freq_distribution"
    },
    "init_cpu_topology": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "running_process_ranking": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "selection_range_cpu_sched_summary/running_process_ranking"
    },
    "running_thread_quadrants": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "selection_range_cpu_sched_summary/running_thread_quadrants"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "*Commit*",
    "*Composite*",
    "*Latch*",
    "*Present*",
    "*commit*",
    "*composite*",
    "*latchBuffer*",
    "*onMessageInvalidate*",
    "*onMessageRefresh*",
    "*postComposition*",
    "*present*",
    "*updateTexImage*",
    "/system/bin/surfaceflinger",
    "surfaceflinger"
  ],
  "skill_id": "sf_composition_in_range",
  "steps": {}
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.frames.timeline"
  ],
  "required_tables": [
    "actual_frame_timeline_slice"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*"
  ],
  "skill_id": "sf_frame_consumption",
  "steps": {
    "sf_consumption_stats": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "sf_frame_consumption/sf_consumption_stats"
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "actual_frame_timeline_slice"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "sf_layer_count_in_range",
  "steps": {
    "layer_list": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "sf_layer_count_in_range/layer_list"
    },
    "layer_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "sf_layer_count_in_range/layer_summary"
    }
  }
}

{
  "adapters": [
    {
      "branches": [
        "api<=28",
        "api29-32",
        "api>=33"
      ],
      "id": "official_android_startup_tags",
      "source": "perfetto stdlib android/startup/startups.sql"
    },
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.startup.startups",
    "android.startup.time_to_display",
    "android.startup.startup_events",
    "android.startup.startup_breakdowns",
    "android.binder"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "bindApplication",
    "handleRelaunchActivity*",
    "performCreate:*",
    "relaunchActivity*"
  ],
  "skill_id": "startup_analysis",
  "steps": {
    "analyze_startups": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "class_loading": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "gc_during_startup": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "get_startups": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "main_thread_binder_blocking": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "main_thread_file_io": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "main_thread_slices": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "main_thread_state_during_startup": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "main_thread_sync_binder": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "sched_latency_during_startup": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "startup_binder": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "startup_breakdown": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "startup_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "startup_evidence_matrix": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "startup_analysis/startup_evidence_matrix"
    },
    "startup_quality": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "startup_analysis/startup_quality"
    }
  }
}

{
  "adapters": [
    {
      "branches": [
        "api<=28",
        "api29-32",
        "api>=33"
      ],
      "id": "official_android_startup_tags",
      "source": "perfetto stdlib android/startup/startups.sql"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.startup.startups",
    "android.binder"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "startup_binder_in_range",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "Binder:*"
  ],
  "skill_id": "startup_binder_pool_analysis",
  "steps": {}
}

{
  "adapters": [
    {
      "branches": [
        "api<=28",
        "api29-32",
        "api>=33"
      ],
      "id": "official_android_startup_tags",
      "source": "perfetto stdlib android/startup/startups.sql"
    },
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.startup.startups",
    "android.startup.startup_breakdowns"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "startup_breakdown_in_range",
  "steps": {}
}

{
  "adapters": [
    {
      "branches": [
        "api<=28",
        "api29-32",
        "api>=33"
      ],
      "id": "official_android_startup_tags",
      "source": "perfetto stdlib android/startup/startups.sql"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.startup.startups"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "startup_class_loading_in_range",
  "steps": {}
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}:*"
  ],
  "skill_id": "startup_cpu_placement_timeline",
  "steps": {}
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.cpu.frequency"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*"
  ],
  "skill_id": "startup_critical_tasks",
  "steps": {}
}

{
  "adapters": [
    {
      "branches": [
        "api<=28",
        "api29-32",
        "api>=33"
      ],
      "id": "official_android_startup_tags",
      "source": "perfetto stdlib android/startup/startups.sql"
    },
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.startup.startups",
    "android.binder",
    "linux.cpu.frequency"
  ],
  "required_tables": [
    "android_startups"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*"
  ],
  "skill_id": "startup_detail",
  "steps": {
    "actionable_main_thread_slices": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "startup_detail/actionable_main_thread_slices"
    },
    "binder_analysis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "binder_pool": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "cpu_core_analysis": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "startup_detail/cpu_core_analysis"
    },
    "cpu_freq_analysis": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "startup_detail/cpu_freq_analysis"
    },
    "cpu_placement_timeline": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "critical_task_system_evidence": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "critical_tasks": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "freq_rampup": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "hot_slice_states": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "init_cpu_topology": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "jit_analysis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "main_thread_file_io": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "main_thread_slices": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "main_thread_state": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "main_thread_sync_binder": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "per_cpu_system_context": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "startup_detail/per_cpu_system_context"
    },
    "preemption": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "startup_detail/preemption"
    },
    "quadrant_analysis": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "startup_detail/quadrant_analysis"
    },
    "sched_latency": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "startup_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "startup_info": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "startup_detail/startup_info"
    },
    "thread_blocking_graph": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    }
  }
}

{
  "adapters": [
    {
      "branches": [
        "api<=28",
        "api29-32",
        "api>=33"
      ],
      "id": "official_android_startup_tags",
      "source": "perfetto stdlib android/startup/startups.sql"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.startup.startups",
    "android.startup.time_to_display",
    "android.startup.startup_events"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "OpenDexFilesFromOat*",
    "PostFork",
    "bindApplication",
    "handleRelaunchActivity*",
    "performCreate:*",
    "performRestart*",
    "relaunchActivity*"
  ],
  "skill_id": "startup_events_in_range",
  "steps": {}
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.cpu.frequency"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "startup_freq_rampup",
  "steps": {}
}

{
  "adapters": [
    {
      "branches": [
        "api<=28",
        "api29-32",
        "api>=33"
      ],
      "id": "official_android_startup_tags",
      "source": "perfetto stdlib android/startup/startups.sql"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.startup.startups"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "startup_gc_in_range",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*"
  ],
  "skill_id": "startup_hot_slice_states",
  "steps": {}
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "*GarbageCollectCache*",
    "*ScopedCodeCacheWrite*",
    "JIT compiling*",
    "Jit thread pool*",
    "JitProfileTask*",
    "Profile Saver*"
  ],
  "skill_id": "startup_jit_analysis",
  "steps": {}
}

{
  "adapters": [
    {
      "branches": [
        "api<=28",
        "api29-32",
        "api>=33"
      ],
      "id": "official_android_startup_tags",
      "source": "perfetto stdlib android/startup/startups.sql"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.startup.startups",
    "android.binder"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "startup_main_thread_binder_blocking_in_range",
  "steps": {}
}

{
  "adapters": [
    {
      "branches": [
        "api<=28",
        "api29-32",
        "api>=33"
      ],
      "id": "official_android_startup_tags",
      "source": "perfetto stdlib android/startup/startups.sql"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.startup.startups"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "startup_main_thread_file_io_in_range",
  "steps": {}
}

{
  "adapters": [
    {
      "branches": [
        "api<=28",
        "api29-32",
        "api>=33"
      ],
      "id": "official_android_startup_tags",
      "source": "perfetto stdlib android/startup/startups.sql"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.startup.startups"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "startup_main_thread_slices_in_range",
  "steps": {}
}

{
  "adapters": [
    {
      "branches": [
        "api<=28",
        "api29-32",
        "api>=33"
      ],
      "id": "official_android_startup_tags",
      "source": "perfetto stdlib android/startup/startups.sql"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.startup.startups"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "startup_main_thread_states_in_range",
  "steps": {}
}

{
  "adapters": [
    {
      "branches": [
        "api<=28",
        "api29-32",
        "api>=33"
      ],
      "id": "official_android_startup_tags",
      "source": "perfetto stdlib android/startup/startups.sql"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.startup.startups",
    "android.binder"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "startup_main_thread_sync_binder_in_range",
  "steps": {}
}

{
  "adapters": [
    {
      "branches": [
        "api<=28",
        "api29-32",
        "api>=33"
      ],
      "id": "official_android_startup_tags",
      "source": "perfetto stdlib android/startup/startups.sql"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.startup.startups"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "startup_sched_latency_in_range",
  "steps": {}
}

{
  "adapters": [
    {
      "branches": [
        "api<=28",
        "api29-32",
        "api>=33"
      ],
      "id": "official_android_startup_tags",
      "source": "perfetto stdlib android/startup/startups.sql"
    },
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.startup.startups",
    "android.startup.time_to_display"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "*GC*",
    "*Lock contention*",
    "*WebView*",
    "*art::Monitor*",
    "*broadcastReceiveReg*",
    "*contentProviderCreate*",
    "*dex2oat*",
    "*dex2oatd*",
    "*monitor contention*",
    "*webview*",
    "JIT compiling*",
    "Lock contention*",
    "VerifyClass*",
    "bindApplication",
    "cpufreq",
    "dlopen:*",
    "dlopen:*chromium*",
    "dlopen:*webview*",
    "handleRelaunchActivity*",
    "inflate*",
    "monitor contention*",
    "performCreate:*",
    "relaunchActivity*",
    "system_server",
    "verifyClass*"
  ],
  "skill_id": "startup_slow_reasons",
  "steps": {
    "slow_reason_checks": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "startup_slow_reasons/slow_reason_checks"
    },
    "startup_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "fixtures": [
            "startup-api31-cold"
          ],
          "status": "verified"
        },
        "32": {
          "fixtures": [
            "startup-api32-warm-smoke"
          ],
          "status": "verified"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "fixtures": [
            "startup-api34-cold"
          ],
          "status": "verified"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "fixtures": [
            "startup-light-api36"
          ],
          "status": "verified"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "startup_slow_reasons/startup_overview"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}:*",
    "*FinalizerDaemon*",
    "*HeapTaskDaemon*",
    "Binder:*",
    "Jit thread pool*"
  ],
  "skill_id": "startup_thread_blocking_graph",
  "steps": {}
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    },
    {
      "id": "android_input_source",
      "selection": "data-source descriptor, build type, config, then rows",
      "version_hint": {
        "proto_input_min_api_hint": 34
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.screen_state",
    "android.input",
    "android.battery_stats"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "*AppTransition*",
    "*InputMethodManager*show*",
    "*InputMethodService*show*",
    "*KeyguardGoing*",
    "*NotificationShade*",
    "*RecentsAnimation*",
    "*RemoteAnimation*",
    "*StatusBar*expand*",
    "*StatusBarWindow*",
    "*Transition*",
    "*WindowAnimation*",
    "*keyguardGoingAway*",
    "*showSoftInput*",
    "*startRecentsActivity*",
    "battery_stats.top",
    "com.android.systemui*"
  ],
  "skill_id": "state_timeline",
  "steps": {
    "app_state_lane": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "state_timeline/app_state_lane"
    },
    "app_state_lane_fallback": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "state_timeline/app_state_lane_fallback"
    },
    "device_state_lane": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "state_timeline/device_state_lane"
    },
    "device_state_lane_fallback": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "state_timeline/device_state_lane_fallback"
    },
    "input_coverage": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "state_timeline/input_coverage"
    },
    "input_state_lane_fallback": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "state_timeline/input_state_lane_fallback"
    },
    "input_state_lane_frames": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "state_timeline/input_state_lane_frames"
    },
    "lane_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "state_timeline/lane_summary"
    },
    "system_state_lane": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "state_timeline/system_state_lane"
    },
    "timeline_bounds": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "state_timeline/timeline_bounds"
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.frames.timeline"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "*Client*",
    "*Commit*",
    "*Composite*",
    "*Fence*",
    "*GLES*",
    "*GPU completion*",
    "*GPU*",
    "*HWC*",
    "*Latch*",
    "*Layer*",
    "*Present*",
    "*Waiting for GPU*",
    "*commit*",
    "*composite*",
    "*fence*",
    "*gpu*",
    "*hwc*",
    "*latchBuffer*",
    "*onMessageInvalidate*",
    "*onMessageRefresh*",
    "*postComposition*",
    "*present*",
    "*updateTexImage*",
    "/system/bin/surfaceflinger",
    "VSYNC-sf",
    "surfaceflinger"
  ],
  "skill_id": "surfaceflinger_analysis",
  "steps": {
    "composition_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "surfaceflinger_analysis/composition_overview"
    },
    "composition_phases": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "surfaceflinger_analysis/composition_phases"
    },
    "data_check": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "surfaceflinger_analysis/data_check"
    },
    "fallback_no_sf_data": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "surfaceflinger_analysis/fallback_no_sf_data"
    },
    "fence_analysis": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "surfaceflinger_analysis/fence_analysis"
    },
    "gpu_hwc_stats": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "surfaceflinger_analysis/gpu_hwc_stats"
    },
    "layer_stats": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "surfaceflinger_analysis/layer_stats"
    },
    "root_cause_classification": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "surfaceflinger_analysis/root_cause_classification"
    },
    "slow_compositions": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "surfaceflinger_analysis/slow_compositions"
    },
    "vsync_config": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "surfaceflinger_analysis/vsync_config"
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.frames.timeline",
    "android.frames.jank_type"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*"
  ],
  "skill_id": "surfaceflinger_module",
  "steps": {
    "frame_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "frame_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "surfaceflinger_module/frame_overview"
    },
    "jank_breakdown": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "surfaceflinger_module/jank_breakdown"
    },
    "thread_timing": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "surfaceflinger_module/thread_timing"
    },
    "worst_frames": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "surfaceflinger_module/worst_frames"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.suspend",
    "android.wakeups"
  ],
  "required_tables": [
    "sched_slice"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "*Suspend*",
    "*WakeLock*",
    "*Wakeup*",
    "*power_state*",
    "*suspend*",
    "*wake_lock*",
    "*wakeup*"
  ],
  "skill_id": "suspend_wakeup_analysis",
  "steps": {
    "check_suspend_data": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "suspend_wakeup_analysis/check_suspend_data"
    },
    "check_suspend_slices": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "suspend_wakeup_analysis/check_suspend_slices"
    },
    "check_wakeup_data": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "suspend_wakeup_analysis/check_wakeup_data"
    },
    "fallback_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "long_suspend_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "suspend_wakeup_analysis/long_suspend_events"
    },
    "suspend_backoff": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "suspend_wakeup_analysis/suspend_backoff"
    },
    "suspend_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "suspend_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "suspend_wakeup_analysis/suspend_overview"
    },
    "suspend_quality_assessment": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "suspend_wakeup_analysis/suspend_quality_assessment"
    },
    "suspend_slice_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "suspend_wakeup_analysis/suspend_slice_overview"
    },
    "wakeup_source_ranking": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "suspend_wakeup_analysis/wakeup_source_ranking"
    },
    "wakeup_timeline": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "suspend_wakeup_analysis/wakeup_timeline"
    },
    "wakeup_type_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "suspend_wakeup_analysis/wakeup_type_overview"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "slice",
    "thread",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "%SystemUI%",
    "%systemui%",
    "*AIDL*",
    "*Binder*",
    "*Bouncer*",
    "*Choreographer#doFrame*",
    "*CollapsedStatusBar*",
    "*DrawFrame*",
    "*Gesture*",
    "*Keyguard*",
    "*LockScreen*",
    "*NavBar*",
    "*Navigation*",
    "*Notification*",
    "*QS*",
    "*QuickSettings*",
    "*Shade*",
    "*StatusBar*",
    "*Swipe*",
    "*Tile*",
    "*Unlock*",
    "*Volume*",
    "*VolumeDialog*",
    "*aidl*",
    "*binder*",
    "*collapse*",
    "*doFrame*",
    "*expand*",
    "*gesture*",
    "*keyguard*",
    "*lockscreen*",
    "*navbar*",
    "*navigation*",
    "*notification*",
    "*shade*",
    "*status_bar*",
    "*statusbar*",
    "*swipe*",
    "*tile*",
    "*unlock*",
    "*volume*",
    "com.android.systemui"
  ],
  "skill_id": "systemui_module",
  "steps": {
    "lockscreen_activities": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "systemui_module/lockscreen_activities"
    },
    "navigation_activities": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "systemui_module/navigation_activities"
    },
    "notification_shade": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "systemui_module/notification_shade"
    },
    "quick_settings": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "systemui_module/quick_settings"
    },
    "statusbar_activities": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "systemui_module/statusbar_activities"
    },
    "systemui_binder": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "systemui_module/systemui_binder"
    },
    "systemui_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "systemui_frames": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "systemui_module/systemui_frames"
    },
    "systemui_main_thread": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "systemui_module/systemui_main_thread"
    },
    "systemui_process": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "systemui_module/systemui_process"
    },
    "volume_dialog": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "systemui_module/volume_dialog"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "system_load_in_range",
  "steps": {}
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}:*"
  ],
  "skill_id": "task_migration_in_range",
  "steps": {
    "init_cpu_topology": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "migration_analysis": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "task_migration_in_range/migration_analysis"
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "slices.with_context",
    "android.frames.timeline"
  ],
  "required_tables": [
    "slice",
    "thread_track",
    "thread",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "*DeferredLayerUpdater*",
    "*SurfaceTexture*",
    "*dequeueBuffer*",
    "*eglSwapBuffers*",
    "*onFrameAvailable*",
    "*queueBuffer*",
    "*updateTexImage*",
    "*vkQueuePresent*"
  ],
  "skill_id": "textureview_producer_frame_timing",
  "steps": {
    "textureview_producer_intervals": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "textureview_producer_frame_timing/textureview_producer_intervals"
    },
    "textureview_signal_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "textureview_producer_frame_timing/textureview_signal_summary"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.cpu.frequency"
  ],
  "required_tables": [
    "counter_track",
    "counter"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "thermal_cooling_device_timeline",
  "steps": {
    "cooling_data_check": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "thermal_cooling_device_timeline/cooling_data_check"
    },
    "cooling_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "thermal_cooling_device_timeline/cooling_summary"
    },
    "cooling_transitions": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "thermal_cooling_device_timeline/cooling_transitions"
    },
    "cooling_unavailable": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "thermal_cooling_device_timeline/cooling_unavailable"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "counter",
    "counter_track"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "*Temp*",
    "*temp*",
    "*temperature*",
    "*thermal*",
    "*tsens*",
    "cpufreq"
  ],
  "skill_id": "thermal_module",
  "steps": {
    "cooling_activity": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "thermal_module/cooling_activity"
    },
    "high_temp_periods": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "thermal_module/high_temp_periods"
    },
    "temperature_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "thermal_module/temperature_overview"
    },
    "temperature_timeline": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "thermal_module/temperature_timeline"
    },
    "thermal_cpu_correlation": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "thermal_module/thermal_cpu_correlation"
    },
    "thermal_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "throttling_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "thermal_module/throttling_events"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "counter",
    "cpu_counter_track"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "cpufreq"
  ],
  "skill_id": "thermal_predictor",
  "steps": {}
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "counter"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "%gpu%",
    "%temp%",
    "%temperature%",
    "%thermal%",
    "%tsens%",
    "cpufreq"
  ],
  "skill_id": "thermal_throttling",
  "steps": {
    "cpu_freq_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "thermal_throttling/cpu_freq_overview"
    },
    "data_check": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "thermal_throttling/data_check"
    },
    "direct_limit_evidence": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "thermal_throttling/direct_limit_evidence"
    },
    "expert_analysis_window": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "thermal_throttling/expert_analysis_window"
    },
    "frequency_drop_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "thermal_throttling/frequency_drop_events"
    },
    "gpu_power_probe": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "high_temp_periods": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "thermal_throttling/high_temp_periods"
    },
    "no_data_fallback": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "thermal_throttling/no_data_fallback"
    },
    "root_cause_classification": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "thermal_throttling/root_cause_classification"
    },
    "thermal_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "thermal_freq_correlation": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "thermal_throttling/thermal_freq_correlation"
    },
    "thermal_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "thermal_throttling/thermal_overview"
    },
    "thermal_predictor_probe": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "thermal_timeline": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "thermal_throttling/thermal_timeline"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.dvfs",
    "linux.cpu.idle",
    "linux.cpu.utilization.process",
    "linux.cpu.utilization.thread",
    "android.gpu.work_period"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "thermal_throttling_chain",
  "steps": {
    "cpu_idle": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "dvfs": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "gpu_work_period": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "limit_attribution": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "mali_state": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "process_util": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "thermal": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "thread_util": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.slices"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "RenderThread",
    "main"
  ],
  "skill_id": "third_party_module",
  "steps": {
    "app_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    },
    "long_main_thread_slices": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "third_party_module/long_main_thread_slices"
    },
    "main_thread_state": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "third_party_module/main_thread_state"
    },
    "render_thread_analysis": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "third_party_module/render_thread_analysis"
    },
    "thread_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "third_party_module/thread_overview"
    }
  }
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "sched",
    "thread",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "*Hwui*",
    "RenderThread"
  ],
  "skill_id": "thread_affinity_violation",
  "steps": {}
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.cpu.frequency"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*"
  ],
  "skill_id": "thread_cpu_placement_timeline",
  "steps": {}
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.cpu.frequency"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*"
  ],
  "skill_id": "thread_preemption_handoffs_in_range",
  "steps": {}
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "linux.cpu.frequency"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*"
  ],
  "skill_id": "thread_system_summary_in_range",
  "steps": {}
}

{
  "adapters": [
    {
      "id": "android_input_source",
      "selection": "data-source descriptor, build type, config, then rows",
      "version_hint": {
        "proto_input_min_api_hint": 34
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.input"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*"
  ],
  "skill_id": "touch_to_display_latency",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "viz.summary.track_event"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "trace_state_track_summary",
  "steps": {}
}

{
  "adapters": [
    {
      "id": "kernel_tracepoints",
      "selection": "available events, trace config/setup errors, schema, then rows"
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "cpu*freq*"
  ],
  "skill_id": "util_tracking_analysis",
  "steps": {}
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "counters.intervals"
  ],
  "required_tables": [
    "counter",
    "counter_track"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "*VSYNC-sf*",
    "VSYNC",
    "VSYNC-sf"
  ],
  "skill_id": "vrr_detection",
  "steps": {
    "refresh_rate_switches": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "vrr_detection/refresh_rate_switches"
    },
    "vrr_mode_detection": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "vrr_detection/vrr_mode_detection"
    },
    "vsync_interval_distribution": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "vrr_detection/vsync_interval_distribution"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "counter",
    "counter_track"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "%VSYNC-app%",
    "%VSYNC-sf%",
    "VSYNC"
  ],
  "skill_id": "vsync_alignment_in_range",
  "steps": {}
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.frames.timeline"
  ],
  "required_tables": [
    "expected_frame_timeline_slice"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "VSYNC-sf"
  ],
  "skill_id": "vsync_config",
  "steps": {
    "detect_vsync_config": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "vsync_config/detect_vsync_config"
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.frames.timeline"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "VSYNC-sf"
  ],
  "skill_id": "vsync_period_detection",
  "steps": {
    "detect_vsync_period": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "vsync_period_detection/detect_vsync_period"
    }
  }
}

{
  "adapters": [
    {
      "id": "android_input_source",
      "selection": "data-source descriptor, build type, config, then rows",
      "version_hint": {
        "proto_input_min_api_hint": 34
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.input"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "VSYNC-app"
  ],
  "skill_id": "vsync_phase_alignment",
  "steps": {
    "phase_analysis": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "vsync_phase_alignment/phase_analysis"
    },
    "phase_distribution": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "vsync_phase_alignment/phase_distribution"
    },
    "vsync_timeline": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "vsync_phase_alignment/vsync_timeline"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "slice"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "*PowerManager*WakeLock*",
    "*SuspendBlocker*",
    "*WakeLock*",
    "*WakeupSource*",
    "*suspend_blocker*",
    "*wake_lock*",
    "*wakelock*",
    "*wakeup_source*"
  ],
  "skill_id": "wakelock_tracking",
  "steps": {
    "suspend_blockers": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "wakelock_tracking/suspend_blockers"
    },
    "wakelock_duration": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "wakelock_tracking/wakelock_duration"
    },
    "wakelock_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "wakelock_tracking/wakelock_events"
    },
    "wakelock_timeline": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "wakelock_tracking/wakelock_timeline"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.wakeups",
    "linux.cpu.idle"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "wakeup_frequency_summary",
  "steps": {
    "wakeup_frequency": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "wakeup_frequency_summary/wakeup_frequency"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "wattson.windows",
    "wattson.aggregation"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "wattson_app_startup_power",
  "steps": {
    "startup_power": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "wattson_app_startup_power/startup_power"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "wattson.aggregation"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [],
  "skill_id": "wattson_rails_power_breakdown",
  "steps": {
    "rails_aggregation": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "wattson_rails_power_breakdown/rails_aggregation"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "wattson.aggregation"
  ],
  "required_tables": [],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "${process_name}",
    "${process_name}:*"
  ],
  "skill_id": "wattson_thread_power_attribution",
  "steps": {
    "thread_attribution": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "wattson_thread_power_attribution/thread_attribution"
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.frames.timeline",
    "slices.with_context"
  ],
  "required_tables": [
    "actual_frame_timeline_slice",
    "slice",
    "thread_track",
    "thread",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "*AwDrawFn*",
    "*Blink*",
    "*Chromium*",
    "*Compositor*",
    "*CrRendererMain*",
    "*DrawFn_DrawGL*",
    "*DrawFunctor*",
    "*DrawGL*",
    "*JavaScript*",
    "*V8*",
    "*sandboxed_process*",
    "*v8*",
    "*webview*",
    "VizCompositorThread*"
  ],
  "skill_id": "webview_drawfunctor_jank_chain",
  "steps": {
    "drawfunctor_frame_overlap": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "webview_drawfunctor_jank_chain/drawfunctor_frame_overlap"
    },
    "drawfunctor_signal_summary": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "webview_drawfunctor_jank_chain/drawfunctor_signal_summary"
    },
    "v8_long_tasks": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    }
  }
}

{
  "adapters": [
    {
      "id": "official_frame_timeline_or_legacy",
      "selection": "actual rows first; legacy Choreographer/DrawFrame fallback",
      "source": "perfetto stdlib android/frames/timeline.sql",
      "version_hint": {
        "frame_timeline_min_api": 31
      }
    }
  ],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [
    "android.frames.timeline"
  ],
  "required_tables": [
    "slice"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "*MajorGC*",
    "*MinorGC*",
    "*V8.GC*",
    "*V8.GCCompactor*",
    "*V8.GCScavenger*",
    "*v8.compile*",
    "*v8.gc*",
    "*v8.run*"
  ],
  "skill_id": "webview_v8_analysis",
  "steps": {
    "v8_compilation": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "webview_v8_analysis/v8_compilation"
    },
    "v8_frame_impact": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "webview_v8_analysis/v8_frame_impact"
    },
    "v8_gc_events": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "webview_v8_analysis/v8_gc_events"
    },
    "v8_script_execution": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "webview_v8_analysis/v8_script_execution"
    }
  }
}

{
  "adapters": [],
  "api": {
    "28": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "29": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "30": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "31": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "32": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "33": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "34": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "35": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "36": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    },
    "37": {
      "reason": "Runtime capabilities are authoritative; no full-Skill exact API fixture",
      "status": "capability_gated"
    }
  },
  "required_modules": [],
  "required_tables": [
    "slice",
    "thread",
    "process"
  ],
  "schema_version": 1,
  "selection_order": [
    "device_capability",
    "trace_config_and_setup_errors",
    "engine_module_and_schema",
    "target_range_row_coverage",
    "api_hint"
  ],
  "signal_patterns": [
    "${package}",
    "${package}:*",
    "%systemui%",
    "*Animation*",
    "*AppTransition*",
    "*Transition*",
    "*WindowAnimation*",
    "*WindowState*",
    "*activityResume*",
    "*activityStart*",
    "*closeAnimation*",
    "*draw*",
    "*finishDrawing*",
    "*hwuiDraw*",
    "*openAnimation*",
    "*performDraw*",
    "*relayoutWindow*",
    "*setVisibility*",
    "*startActivity*",
    "*startingWindow*",
    "*windowFocus*",
    "system_server"
  ],
  "skill_id": "wms_module",
  "steps": {
    "activity_transitions": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "wms_module/activity_transitions"
    },
    "slow_animations": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "wms_module/slow_animations"
    },
    "window_animation_overview": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "wms_module/window_animation_overview"
    },
    "window_draw_latency": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "wms_module/window_draw_latency"
    },
    "window_state_changes": {
      "api": {
        "28": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "29": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "30": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "31": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "32": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "33": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "34": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "35": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "36": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        },
        "37": {
          "reason": "No exact API semantic fixture; runtime capability proof required",
          "status": "capability_gated"
        }
      },
      "query_id": "wms_module/window_state_changes"
    },
    "wms_diagnosis": {
      "api": {
        "28": {
          "status": "capability_gated"
        },
        "29": {
          "status": "capability_gated"
        },
        "30": {
          "status": "capability_gated"
        },
        "31": {
          "status": "capability_gated"
        },
        "32": {
          "status": "capability_gated"
        },
        "33": {
          "status": "capability_gated"
        },
        "34": {
          "status": "capability_gated"
        },
        "35": {
          "status": "capability_gated"
        },
        "36": {
          "status": "capability_gated"
        },
        "37": {
          "status": "capability_gated"
        }
      },
      "query_id": null
    }
  }
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "ams_module/startup_timing",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/ams_module/startup_timing.sql",
      "sha256": "7aaf40d8ed48b73bc5573dfa0c1cb254dc8e0d2f852d4ac56dc139b451ab9a40",
      "signal_patterns": [],
      "skill_id": "ams_module",
      "source": {
        "path": "backend/skills/modules/framework/ams_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "bfd2cd1f208acc814f9da8ed0ec0b02c0d5fd7226da25bec898e8de516e315cd"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.startup.startups",
          "android.startup.time_to_display",
          "android.broadcasts"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "startup_timing",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "ams_module/startup_phases",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/ams_module/startup_phases.sql",
      "sha256": "13fedfc3bace1f4f9c1bc4cd97b027671f1229a080d19ee05fea0ea463334a67",
      "signal_patterns": [
        "%Choreographer%doFrame%",
        "%activityResume%",
        "%activityStart%",
        "%bindApplication%"
      ],
      "skill_id": "ams_module",
      "source": {
        "path": "backend/skills/modules/framework/ams_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "bfd2cd1f208acc814f9da8ed0ec0b02c0d5fd7226da25bec898e8de516e315cd"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.startup.startups",
          "android.startup.time_to_display",
          "android.broadcasts"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "startup_phases",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "ams_module/broadcast_analysis",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/ams_module/broadcast_analysis.sql",
      "sha256": "07174a7b7381ece72b0bfc7511571da7a4dfb6fb7e8cc01bf211800a66ff9f2f",
      "signal_patterns": [],
      "skill_id": "ams_module",
      "source": {
        "path": "backend/skills/modules/framework/ams_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "bfd2cd1f208acc814f9da8ed0ec0b02c0d5fd7226da25bec898e8de516e315cd"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.startup.startups",
          "android.startup.time_to_display",
          "android.broadcasts"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "broadcast_analysis",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "ams_module"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "android_app_background_power_state/power_state_capability",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_app_background_power_state/power_state_capability.sql",
      "sha256": "9bda04b117059435cb2151bf99408244493b50cbe92cae2656d0a2e5d92b111b",
      "signal_patterns": [
        "Freeze *:*",
        "android_app_wakelocks",
        "android_battery_stats_event_slices",
        "android_freezer_events",
        "android_freezer_state_statsd",
        "android_standby_bucket",
        "app_freeze_changed",
        "app_standby_bucket_changed"
      ],
      "skill_id": "android_app_background_power_state",
      "source": {
        "path": "backend/skills/atomic/android_app_background_power_state.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "4ce3166f6ef8db3eca68f7a14cb6d6164abb3f15de2db690e545acc15ef4ff86"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.app_wakelocks",
          "android.battery_stats",
          "android.standby_bucket",
          "android.freezer"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "power_state_capability",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "android_app_background_power_state/app_wakelock_summary",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_app_background_power_state/app_wakelock_summary.sql",
      "sha256": "504dd9a542c50fc6a15795c251a4929acd273458514e31c5f46032c9ec525ee3",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "android_app_background_power_state",
      "source": {
        "path": "backend/skills/atomic/android_app_background_power_state.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "4ce3166f6ef8db3eca68f7a14cb6d6164abb3f15de2db690e545acc15ef4ff86"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.app_wakelocks",
          "android.battery_stats",
          "android.standby_bucket",
          "android.freezer"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "app_wakelock_summary",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "android_app_background_power_state/app_wakelock_summary_battery_stats",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_app_background_power_state/app_wakelock_summary_battery_stats.sql",
      "sha256": "3536baee52870b6a72b011a50d9c4c8b809e46c0c328c5dc6e096af45fb3465c",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "battery_stats.longwake"
      ],
      "skill_id": "android_app_background_power_state",
      "source": {
        "path": "backend/skills/atomic/android_app_background_power_state.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "4ce3166f6ef8db3eca68f7a14cb6d6164abb3f15de2db690e545acc15ef4ff86"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.app_wakelocks",
          "android.battery_stats",
          "android.standby_bucket",
          "android.freezer"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "app_wakelock_summary_battery_stats",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "android_app_background_power_state/standby_bucket_residency",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_app_background_power_state/standby_bucket_residency.sql",
      "sha256": "27dbcc72057a9d80724b8661c200b5ad23ec9fa714de5d220bf533fc240894f5",
      "signal_patterns": [],
      "skill_id": "android_app_background_power_state",
      "source": {
        "path": "backend/skills/atomic/android_app_background_power_state.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "4ce3166f6ef8db3eca68f7a14cb6d6164abb3f15de2db690e545acc15ef4ff86"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.app_wakelocks",
          "android.battery_stats",
          "android.standby_bucket",
          "android.freezer"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "standby_bucket_residency",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "android_app_background_power_state/freezer_summary",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_app_background_power_state/freezer_summary.sql",
      "sha256": "361eaa3a0637b4921cd459ef8b8aaf7081f348bd6e9b6bfa84b23e2a1c67a751",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "android_app_background_power_state",
      "source": {
        "path": "backend/skills/atomic/android_app_background_power_state.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "4ce3166f6ef8db3eca68f7a14cb6d6164abb3f15de2db690e545acc15ef4ff86"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.app_wakelocks",
          "android.battery_stats",
          "android.standby_bucket",
          "android.freezer"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "freezer_summary",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "android_app_background_power_state/freezer_summary_slices",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_app_background_power_state/freezer_summary_slices.sql",
      "sha256": "ab6d1621a6ffd6131e97b2ab0efe0b184ab1e8ece21eb2abb0bd3a47441e56b9",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "android_app_background_power_state",
      "source": {
        "path": "backend/skills/atomic/android_app_background_power_state.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "4ce3166f6ef8db3eca68f7a14cb6d6164abb3f15de2db690e545acc15ef4ff86"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.app_wakelocks",
          "android.battery_stats",
          "android.standby_bucket",
          "android.freezer"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "freezer_summary_slices",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "android_app_background_power_state"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "android_bitmap_memory_per_process/bitmap_memory",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_bitmap_memory_per_process/bitmap_memory.sql",
      "sha256": "1716d67e28626d1e96b2b1ffacd98237ee09285584695fc6f96142efdfd0d9b1",
      "signal_patterns": [],
      "skill_id": "android_bitmap_memory_per_process",
      "source": {
        "path": "backend/skills/atomic/android_bitmap_memory_per_process.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "c60050ad32c18950da78069dabe941919f7dd55aa3df9ac7ad86d51254da582d"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.bitmaps",
          "android.memory.heap_graph.bitmap"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "bitmap_memory",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/heap_target_process.sql",
            "source_sha256": "e6dc119ff332e00bd847e30c45172809b69fd93bbc3e625282be768db242c90a"
          }
        ],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "package",
          "process_name",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "android_bitmap_memory_per_process/heap_bitmap_availability",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_bitmap_memory_per_process/heap_bitmap_availability.sql",
      "sha256": "5bcb00d3f0b0d7f7cccfbe3dfa3941d6d6a8399d04d73578f37851c4729e0cc2",
      "signal_patterns": [
        "heap_graph_bitmaps"
      ],
      "skill_id": "android_bitmap_memory_per_process",
      "source": {
        "path": "backend/skills/atomic/android_bitmap_memory_per_process.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "c60050ad32c18950da78069dabe941919f7dd55aa3df9ac7ad86d51254da582d"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.bitmaps",
          "android.memory.heap_graph.bitmap"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "heap_bitmap_availability",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "android_bitmap_memory_per_process/heap_bitmap_metadata",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_bitmap_memory_per_process/heap_bitmap_metadata.sql",
      "sha256": "4f015c54fef3f48cfae1356bd0573579a4c1daa845ab5063bd431241dde665e7",
      "signal_patterns": [],
      "skill_id": "android_bitmap_memory_per_process",
      "source": {
        "path": "backend/skills/atomic/android_bitmap_memory_per_process.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "c60050ad32c18950da78069dabe941919f7dd55aa3df9ac7ad86d51254da582d"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.bitmaps",
          "android.memory.heap_graph.bitmap"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "heap_bitmap_metadata",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/heap_target_process.sql",
            "source_sha256": "e6dc119ff332e00bd847e30c45172809b69fd93bbc3e625282be768db242c90a"
          }
        ],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "package",
          "process_name",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "android_bitmap_memory_per_process/heap_bitmap_sender_attribution",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_bitmap_memory_per_process/heap_bitmap_sender_attribution.sql",
      "sha256": "8af3833641e69a0ae0bba38146d0ca8f460f78a4740bd9f5e31a17c6d2cfb2ff",
      "signal_patterns": [],
      "skill_id": "android_bitmap_memory_per_process",
      "source": {
        "path": "backend/skills/atomic/android_bitmap_memory_per_process.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "c60050ad32c18950da78069dabe941919f7dd55aa3df9ac7ad86d51254da582d"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.bitmaps",
          "android.memory.heap_graph.bitmap"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "heap_bitmap_sender_attribution",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/heap_target_process.sql",
            "source_sha256": "e6dc119ff332e00bd847e30c45172809b69fd93bbc3e625282be768db242c90a"
          }
        ],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "package",
          "process_name",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "android_bitmap_memory_per_process"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "android_dvfs_counter_stats/dvfs_stats",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_dvfs_counter_stats/dvfs_stats.sql",
      "sha256": "be74dcf3203ca64e8a6f7f3c81ecf1abda8e5f1cac7981019ad0a14604de2a1b",
      "signal_patterns": [],
      "skill_id": "android_dvfs_counter_stats",
      "source": {
        "path": "backend/skills/atomic/android_dvfs_counter_stats.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "cf8599903da332db1aff2c03d179ffd4c5dd3ecd90fed3c66e1aafa3d74df84a"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.dvfs"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "dvfs_stats",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "android_dvfs_counter_stats"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "android_gpu_work_period_track/gpu_work",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_gpu_work_period_track/gpu_work.sql",
      "sha256": "7123278cdedde0b73ccc904bc0630566fb6fa1072505980083768a094d2c3dff",
      "signal_patterns": [],
      "skill_id": "android_gpu_work_period_track",
      "source": {
        "path": "backend/skills/atomic/android_gpu_work_period_track.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "dad0f300552c8a78618be018d8930c345109988d414c37fcef819ee4752758f5"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.gpu.work_period"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gpu_work",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "android_gpu_work_period_track"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "android_heap_dominator_path_extract/data_check",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_heap_dominator_path_extract/data_check.sql",
      "sha256": "743fe002d16076189ca39390da5b0c6671f307e5ee798ab48e52e5ce6acf266a",
      "signal_patterns": [
        "heap_graph*",
        "hprof*"
      ],
      "skill_id": "android_heap_dominator_path_extract",
      "source": {
        "path": "backend/skills/composite/android_heap_dominator_path_extract.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "79a6054d4d6744e18381baa97106c13e0a4e11f4c8655ba9ade28004904aab52"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.heap_graph.dominator_class_tree",
          "graphs.scan",
          "graphs.hierarchy"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "data_check",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/heap_target_process.sql",
            "source_sha256": "e6dc119ff332e00bd847e30c45172809b69fd93bbc3e625282be768db242c90a"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/heap_graph_dump_scope.sql",
            "source_sha256": "4b0db7618d6d3b9db6b371cf8ebe963e88ddfd4738b7115a184fe2cbeae826f9"
          }
        ],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "graph_sample_ts",
          "package",
          "process_name",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "android_heap_dominator_path_extract/dominator_tree_pass",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_heap_dominator_path_extract/dominator_tree_pass.sql",
      "sha256": "a22f8a5a521f846efe237890c244de4e4a0f147fb2c7e29b5f19569ae5376df5",
      "signal_patterns": [],
      "skill_id": "android_heap_dominator_path_extract",
      "source": {
        "path": "backend/skills/composite/android_heap_dominator_path_extract.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "79a6054d4d6744e18381baa97106c13e0a4e11f4c8655ba9ade28004904aab52"
      },
      "sql_dependencies": {
        "creates": [
          {
            "kind": "table",
            "name": "__sp_heap_dominator_cumulatives"
          },
          {
            "kind": "table",
            "name": "__sp_heap_top_dominator_nodes"
          },
          {
            "kind": "table",
            "name": "__sp_heap_dominator_ancestor_ids"
          },
          {
            "kind": "table",
            "name": "__sp_heap_dominator_labels"
          },
          {
            "kind": "table",
            "name": "__sp_heap_dominator_paths"
          }
        ],
        "declared_modules": [
          "android.memory.heap_graph.dominator_class_tree",
          "graphs.scan",
          "graphs.hierarchy"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "dominator_tree_pass",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "android_heap_dominator_path_extract/dominator_paths",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_heap_dominator_path_extract/dominator_paths.sql",
      "sha256": "8ad26f6ad0208594082de1a2b50dbb95bc542b79603724b18ae600f270884dd0",
      "signal_patterns": [
        "heap_graph*",
        "hprof*"
      ],
      "skill_id": "android_heap_dominator_path_extract",
      "source": {
        "path": "backend/skills/composite/android_heap_dominator_path_extract.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "79a6054d4d6744e18381baa97106c13e0a4e11f4c8655ba9ade28004904aab52"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.heap_graph.dominator_class_tree",
          "graphs.scan",
          "graphs.hierarchy"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "__sp_heap_dominator_cumulatives",
          "__sp_heap_dominator_paths",
          "__sp_heap_top_dominator_nodes"
        ],
        "setup_queries": [
          "android_heap_dominator_path_extract/dominator_tree_pass"
        ]
      },
      "step_id": "dominator_paths",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/heap_target_process.sql",
            "source_sha256": "e6dc119ff332e00bd847e30c45172809b69fd93bbc3e625282be768db242c90a"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/heap_graph_dump_scope.sql",
            "source_sha256": "4b0db7618d6d3b9db6b371cf8ebe963e88ddfd4738b7115a184fe2cbeae826f9"
          }
        ],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "graph_sample_ts",
          "max_rows",
          "package",
          "process_name",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "android_heap_dominator_path_extract"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "heap_graph"
        ]
      },
      "id": "android_heap_graph_class_growth/heap_class_table",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_heap_graph_class_growth/heap_class_table.sql",
      "sha256": "6dc771454eedbf2156d4c4bed220117b99af5b56e2adf518fb7671c07848c42d",
      "signal_patterns": [],
      "skill_id": "android_heap_graph_class_growth",
      "source": {
        "path": "backend/skills/atomic/android_heap_graph_class_growth.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "7f3005702a7a0b160c86748bb1b535119fb9647f5d1bfa60496bf33c11551a55"
      },
      "sql_dependencies": {
        "creates": [
          {
            "kind": "table",
            "name": "__sp_heap_class_growth_classes"
          }
        ],
        "declared_modules": [
          "android.memory.heap_graph.heap_graph_class_aggregation",
          "android.memory.heap_graph.heap_graph_stats"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "heap_class_table",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "heap_graph"
        ]
      },
      "id": "android_heap_graph_class_growth/class_growth_availability",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_heap_graph_class_growth/class_growth_availability.sql",
      "sha256": "d0ba472f91f5a208b416a1f62115b17a144b57f1fc3f5e7025724b27dc50419e",
      "signal_patterns": [
        "heap_graph*",
        "hprof*"
      ],
      "skill_id": "android_heap_graph_class_growth",
      "source": {
        "path": "backend/skills/atomic/android_heap_graph_class_growth.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "7f3005702a7a0b160c86748bb1b535119fb9647f5d1bfa60496bf33c11551a55"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.heap_graph.heap_graph_class_aggregation",
          "android.memory.heap_graph.heap_graph_stats"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": [
          "android_heap_graph_class_growth/heap_class_table"
        ]
      },
      "step_id": "class_growth_availability",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/heap_target_process.sql",
            "source_sha256": "e6dc119ff332e00bd847e30c45172809b69fd93bbc3e625282be768db242c90a"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/heap_graph_dump_scope.sql",
            "source_sha256": "4b0db7618d6d3b9db6b371cf8ebe963e88ddfd4738b7115a184fe2cbeae826f9"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/heap_graph_selected_dumps.sql",
            "source_sha256": "a6741ed12a05a5d489c99f5e399b1028be65277da87f180e5adcae2258cdd1ec"
          }
        ],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "dump_selector",
          "graph_sample_ts",
          "package",
          "process_name",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "heap_graph"
        ]
      },
      "id": "android_heap_graph_class_growth/class_dump_inventory",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_heap_graph_class_growth/class_dump_inventory.sql",
      "sha256": "07cad8653b292b436f5e031d10f26ac38c8132fcd74a4b74c4943e098333e080",
      "signal_patterns": [
        "heap_graph*",
        "hprof*"
      ],
      "skill_id": "android_heap_graph_class_growth",
      "source": {
        "path": "backend/skills/atomic/android_heap_graph_class_growth.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "7f3005702a7a0b160c86748bb1b535119fb9647f5d1bfa60496bf33c11551a55"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.heap_graph.heap_graph_class_aggregation",
          "android.memory.heap_graph.heap_graph_stats"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "__sp_heap_class_growth_classes"
        ],
        "setup_queries": [
          "android_heap_graph_class_growth/heap_class_table"
        ]
      },
      "step_id": "class_dump_inventory",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/heap_target_process.sql",
            "source_sha256": "e6dc119ff332e00bd847e30c45172809b69fd93bbc3e625282be768db242c90a"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/heap_graph_dump_scope.sql",
            "source_sha256": "4b0db7618d6d3b9db6b371cf8ebe963e88ddfd4738b7115a184fe2cbeae826f9"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/heap_graph_selected_dumps.sql",
            "source_sha256": "a6741ed12a05a5d489c99f5e399b1028be65277da87f180e5adcae2258cdd1ec"
          }
        ],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "dump_selector",
          "graph_sample_ts",
          "package",
          "process_name",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "heap_graph"
        ]
      },
      "id": "android_heap_graph_class_growth/class_ranking",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_heap_graph_class_growth/class_ranking.sql",
      "sha256": "ff22087b3f406270c497c64ba1c3cc602a067817af41fa0de6861e62d2b88b33",
      "signal_patterns": [
        "heap_graph*",
        "hprof*"
      ],
      "skill_id": "android_heap_graph_class_growth",
      "source": {
        "path": "backend/skills/atomic/android_heap_graph_class_growth.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "7f3005702a7a0b160c86748bb1b535119fb9647f5d1bfa60496bf33c11551a55"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.heap_graph.heap_graph_class_aggregation",
          "android.memory.heap_graph.heap_graph_stats"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "__sp_heap_class_growth_classes"
        ],
        "setup_queries": [
          "android_heap_graph_class_growth/heap_class_table"
        ]
      },
      "step_id": "class_ranking",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/heap_target_process.sql",
            "source_sha256": "e6dc119ff332e00bd847e30c45172809b69fd93bbc3e625282be768db242c90a"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/heap_graph_dump_scope.sql",
            "source_sha256": "4b0db7618d6d3b9db6b371cf8ebe963e88ddfd4738b7115a184fe2cbeae826f9"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/heap_graph_selected_dumps.sql",
            "source_sha256": "a6741ed12a05a5d489c99f5e399b1028be65277da87f180e5adcae2258cdd1ec"
          }
        ],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "dump_selector",
          "graph_sample_ts",
          "max_rows",
          "package",
          "process_name",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "heap_graph"
        ]
      },
      "id": "android_heap_graph_class_growth/requested_classes",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_heap_graph_class_growth/requested_classes.sql",
      "sha256": "d1e44c5f8aeeef5b92f0d51197e11fe0648a76ea0fe235d881cf283b894d0e05",
      "signal_patterns": [
        "heap_graph*",
        "hprof*"
      ],
      "skill_id": "android_heap_graph_class_growth",
      "source": {
        "path": "backend/skills/atomic/android_heap_graph_class_growth.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "7f3005702a7a0b160c86748bb1b535119fb9647f5d1bfa60496bf33c11551a55"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.heap_graph.heap_graph_class_aggregation",
          "android.memory.heap_graph.heap_graph_stats"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "__sp_heap_class_growth_classes"
        ],
        "setup_queries": [
          "android_heap_graph_class_growth/heap_class_table"
        ]
      },
      "step_id": "requested_classes",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/heap_target_process.sql",
            "source_sha256": "e6dc119ff332e00bd847e30c45172809b69fd93bbc3e625282be768db242c90a"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/heap_graph_dump_scope.sql",
            "source_sha256": "4b0db7618d6d3b9db6b371cf8ebe963e88ddfd4738b7115a184fe2cbeae826f9"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/heap_graph_selected_dumps.sql",
            "source_sha256": "a6741ed12a05a5d489c99f5e399b1028be65277da87f180e5adcae2258cdd1ec"
          }
        ],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "class_names",
          "dump_selector",
          "graph_sample_ts",
          "package",
          "process_name",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "heap_graph"
        ]
      },
      "id": "android_heap_graph_class_growth/class_growth_within_trace",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_heap_graph_class_growth/class_growth_within_trace.sql",
      "sha256": "4c2558a28665a9ee46ad83dada01f751595b7751e5415d7d47e2401dbc9a094d",
      "signal_patterns": [
        "heap_graph*",
        "hprof*"
      ],
      "skill_id": "android_heap_graph_class_growth",
      "source": {
        "path": "backend/skills/atomic/android_heap_graph_class_growth.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "7f3005702a7a0b160c86748bb1b535119fb9647f5d1bfa60496bf33c11551a55"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.heap_graph.heap_graph_class_aggregation",
          "android.memory.heap_graph.heap_graph_stats"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "__sp_heap_class_growth_classes"
        ],
        "setup_queries": [
          "android_heap_graph_class_growth/heap_class_table"
        ]
      },
      "step_id": "class_growth_within_trace",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/heap_target_process.sql",
            "source_sha256": "e6dc119ff332e00bd847e30c45172809b69fd93bbc3e625282be768db242c90a"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/heap_graph_dump_scope.sql",
            "source_sha256": "4b0db7618d6d3b9db6b371cf8ebe963e88ddfd4738b7115a184fe2cbeae826f9"
          }
        ],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "graph_sample_ts",
          "max_rows",
          "package",
          "process_name",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "android_heap_graph_class_growth"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "heap_graph"
        ]
      },
      "id": "android_heap_graph_leak_candidates/leak_candidates",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_heap_graph_leak_candidates/leak_candidates.sql",
      "sha256": "1003be1c51fe25d237f3a7843fdebbb487376ace83c284e3479be1ca96d32440",
      "signal_patterns": [
        "*",
        "*onCreate*",
        "*onDestroy*",
        "*onDestroyView*",
        "*onPause*",
        "*onResume*",
        "*onStart*",
        "*onStop*",
        "heap_graph*",
        "hprof*"
      ],
      "skill_id": "android_heap_graph_leak_candidates",
      "source": {
        "path": "backend/skills/atomic/android_heap_graph_leak_candidates.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "e2af69bca6b92ed9ca91e615637c3e86b5fc9daba767af5db4f2ef7225f98f20"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.heap_graph.excluded_refs"
        ],
        "drops": [],
        "required_tables": [
          "heap_graph_object",
          "heap_graph_class",
          "heap_graph_reference"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "leak_candidates",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/heap_target_process.sql",
            "source_sha256": "e6dc119ff332e00bd847e30c45172809b69fd93bbc3e625282be768db242c90a"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/heap_graph_dump_scope.sql",
            "source_sha256": "4b0db7618d6d3b9db6b371cf8ebe963e88ddfd4738b7115a184fe2cbeae826f9"
          }
        ],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "class_name_glob",
          "graph_sample_ts",
          "lifecycle_slice_prefix",
          "max_candidates",
          "package",
          "process_name",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "heap_graph"
        ]
      },
      "id": "android_heap_graph_leak_candidates/reference_holders",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_heap_graph_leak_candidates/reference_holders.sql",
      "sha256": "9e9373866550a357e982e3d84bece35c7f51bf931c8404add70970f206c9782e",
      "signal_patterns": [
        "*",
        "*onCreate*",
        "*onDestroy*",
        "*onDestroyView*",
        "*onPause*",
        "*onResume*",
        "*onStart*",
        "*onStop*",
        "heap_graph*",
        "hprof*"
      ],
      "skill_id": "android_heap_graph_leak_candidates",
      "source": {
        "path": "backend/skills/atomic/android_heap_graph_leak_candidates.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "e2af69bca6b92ed9ca91e615637c3e86b5fc9daba767af5db4f2ef7225f98f20"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.heap_graph.excluded_refs"
        ],
        "drops": [],
        "required_tables": [
          "heap_graph_object",
          "heap_graph_class",
          "heap_graph_reference"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "reference_holders",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/heap_target_process.sql",
            "source_sha256": "e6dc119ff332e00bd847e30c45172809b69fd93bbc3e625282be768db242c90a"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/heap_graph_dump_scope.sql",
            "source_sha256": "4b0db7618d6d3b9db6b371cf8ebe963e88ddfd4738b7115a184fe2cbeae826f9"
          }
        ],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "class_name_glob",
          "graph_sample_ts",
          "lifecycle_slice_prefix",
          "max_candidates",
          "max_reference_edges",
          "package",
          "process_name",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "android_heap_graph_leak_candidates"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "heap_graph"
        ]
      },
      "id": "android_heap_graph_summary/heap_graph_dump_sizes",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_heap_graph_summary/heap_graph_dump_sizes.sql",
      "sha256": "43473852e5ecfaec3294220feef3bb4db1a805f7736d37def7738b3cd3892281",
      "signal_patterns": [],
      "skill_id": "android_heap_graph_summary",
      "source": {
        "path": "backend/skills/atomic/android_heap_graph_summary.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "de6251b10137d1d773f7eef2c440c14fbe12fc4312d3dee7872e20ec632eb0e8"
      },
      "sql_dependencies": {
        "creates": [
          {
            "kind": "table",
            "name": "__sp_heap_graph_dump_sizes"
          }
        ],
        "declared_modules": [
          "android.memory.heap_graph.heap_graph_stats",
          "android.memory.heap_graph.class_summary_tree"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "heap_graph_dump_sizes",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "heap_graph"
        ]
      },
      "id": "android_heap_graph_summary/heap_graph_availability",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_heap_graph_summary/heap_graph_availability.sql",
      "sha256": "bdcea42375cd1b788a552c1857a200960dc0572e1243b88f08f3d1f59feb5144",
      "signal_patterns": [
        "heap_graph*",
        "hprof*",
        "truncated"
      ],
      "skill_id": "android_heap_graph_summary",
      "source": {
        "path": "backend/skills/atomic/android_heap_graph_summary.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "de6251b10137d1d773f7eef2c440c14fbe12fc4312d3dee7872e20ec632eb0e8"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.heap_graph.heap_graph_stats",
          "android.memory.heap_graph.class_summary_tree"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "__sp_heap_graph_dump_sizes"
        ],
        "setup_queries": [
          "android_heap_graph_summary/heap_graph_dump_sizes"
        ]
      },
      "step_id": "heap_graph_availability",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/heap_target_process.sql",
            "source_sha256": "e6dc119ff332e00bd847e30c45172809b69fd93bbc3e625282be768db242c90a"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/heap_graph_dump_scope.sql",
            "source_sha256": "4b0db7618d6d3b9db6b371cf8ebe963e88ddfd4738b7115a184fe2cbeae826f9"
          }
        ],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "graph_sample_ts",
          "package",
          "process_name",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "heap_graph"
        ]
      },
      "id": "android_heap_graph_summary/heap_graph_samples",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_heap_graph_summary/heap_graph_samples.sql",
      "sha256": "020b17b4f81be6861cd6da466e1397fb64d0184b7dc291206771fb340cb43fcd",
      "signal_patterns": [
        "heap_graph*",
        "hprof*"
      ],
      "skill_id": "android_heap_graph_summary",
      "source": {
        "path": "backend/skills/atomic/android_heap_graph_summary.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "de6251b10137d1d773f7eef2c440c14fbe12fc4312d3dee7872e20ec632eb0e8"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.heap_graph.heap_graph_stats",
          "android.memory.heap_graph.class_summary_tree"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "__sp_heap_graph_dump_sizes"
        ],
        "setup_queries": [
          "android_heap_graph_summary/heap_graph_dump_sizes"
        ]
      },
      "step_id": "heap_graph_samples",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/heap_target_process.sql",
            "source_sha256": "e6dc119ff332e00bd847e30c45172809b69fd93bbc3e625282be768db242c90a"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/heap_graph_dump_scope.sql",
            "source_sha256": "4b0db7618d6d3b9db6b371cf8ebe963e88ddfd4738b7115a184fe2cbeae826f9"
          }
        ],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "graph_sample_ts",
          "package",
          "process_name",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "heap_graph"
        ]
      },
      "id": "android_heap_graph_summary/heap_graph_truncation",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_heap_graph_summary/heap_graph_truncation.sql",
      "sha256": "c620037f1cba1524d8a1db46c2ed45e234fb04fef809e1a0d96f07d712d492eb",
      "signal_patterns": [
        "heap_graph*",
        "hprof*"
      ],
      "skill_id": "android_heap_graph_summary",
      "source": {
        "path": "backend/skills/atomic/android_heap_graph_summary.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "de6251b10137d1d773f7eef2c440c14fbe12fc4312d3dee7872e20ec632eb0e8"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.heap_graph.heap_graph_stats",
          "android.memory.heap_graph.class_summary_tree"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": [
          "android_heap_graph_summary/heap_graph_dump_sizes"
        ]
      },
      "step_id": "heap_graph_truncation",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/heap_target_process.sql",
            "source_sha256": "e6dc119ff332e00bd847e30c45172809b69fd93bbc3e625282be768db242c90a"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/heap_graph_dump_scope.sql",
            "source_sha256": "4b0db7618d6d3b9db6b371cf8ebe963e88ddfd4738b7115a184fe2cbeae826f9"
          }
        ],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "graph_sample_ts",
          "package",
          "process_name",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "heap_graph"
        ]
      },
      "id": "android_heap_graph_summary/top_retained_classes",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_heap_graph_summary/top_retained_classes.sql",
      "sha256": "5129a4fc4e0e7f8da40a481d916daea64723fa06c42c6309f932ee0efc105eb1",
      "signal_patterns": [
        "*Activity*",
        "*Fragment*",
        "heap_graph*",
        "hprof*"
      ],
      "skill_id": "android_heap_graph_summary",
      "source": {
        "path": "backend/skills/atomic/android_heap_graph_summary.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "de6251b10137d1d773f7eef2c440c14fbe12fc4312d3dee7872e20ec632eb0e8"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.heap_graph.heap_graph_stats",
          "android.memory.heap_graph.class_summary_tree"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "__sp_heap_graph_dump_sizes"
        ],
        "setup_queries": [
          "android_heap_graph_summary/heap_graph_dump_sizes"
        ]
      },
      "step_id": "top_retained_classes",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/heap_target_process.sql",
            "source_sha256": "e6dc119ff332e00bd847e30c45172809b69fd93bbc3e625282be768db242c90a"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/heap_graph_dump_scope.sql",
            "source_sha256": "4b0db7618d6d3b9db6b371cf8ebe963e88ddfd4738b7115a184fe2cbeae826f9"
          }
        ],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "graph_sample_ts",
          "max_rows",
          "package",
          "process_name",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "android_heap_graph_summary"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "android_job_scheduler_events/job_events",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_job_scheduler_events/job_events.sql",
      "sha256": "f3e07bf9df35a6a12f9093e853e4e70c5ec562bcd033862089d9533115da6bd9",
      "signal_patterns": [],
      "skill_id": "android_job_scheduler_events",
      "source": {
        "path": "backend/skills/atomic/android_job_scheduler_events.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "ba9540e773bd4ae67b91b141674cfe0b66e89de879fc3d328ea0e98c480c110b"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.job_scheduler"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "job_events",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "android_job_scheduler_events"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "android_kernel_wakelock_summary/wakelock_summary",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_kernel_wakelock_summary/wakelock_summary.sql",
      "sha256": "6c752e86f73d632e52604af761d1e60ee0e862f3464080b5451535f8eaf84dd3",
      "signal_patterns": [],
      "skill_id": "android_kernel_wakelock_summary",
      "source": {
        "path": "backend/skills/atomic/android_kernel_wakelock_summary.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "b87beb54fd7e610df76952ec79d79249a37e510e08dd650fae66893a20e4af63"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.kernel_wakelocks"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "wakelock_summary",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "android_kernel_wakelock_summary"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "android_memory_v57_ai_diagnostics/data_check",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_memory_v57_ai_diagnostics/data_check.sql",
      "sha256": "86728dd02920bd4c472589a188f494bee020f611656ee913d337670dbd1bc940",
      "signal_patterns": [],
      "skill_id": "android_memory_v57_ai_diagnostics",
      "source": {
        "path": "backend/skills/composite/android_memory_v57_ai_diagnostics.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "bb2e6b53cdde9eef70dca527316ceb2d87cdaed5c609cafd9ec516f76b3cd770"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "prelude.after_eof.memory",
          "prelude.after_eof.views",
          "android.memory.heap_graph.heap_graph_stats",
          "android.memory.heap_graph.class_summary_tree"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "data_check",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "heap_graph"
        ]
      },
      "id": "android_memory_v57_ai_diagnostics/heap_graph_repeated_objects",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_memory_v57_ai_diagnostics/heap_graph_repeated_objects.sql",
      "sha256": "993dab1aeb5bffafde92eef962020c37c1e5b4d9956c0803c00908ab2f1528ab",
      "signal_patterns": [
        "heap_graph*",
        "hprof*"
      ],
      "skill_id": "android_memory_v57_ai_diagnostics",
      "source": {
        "path": "backend/skills/composite/android_memory_v57_ai_diagnostics.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "bb2e6b53cdde9eef70dca527316ceb2d87cdaed5c609cafd9ec516f76b3cd770"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "prelude.after_eof.memory",
          "prelude.after_eof.views",
          "android.memory.heap_graph.heap_graph_stats",
          "android.memory.heap_graph.class_summary_tree"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "heap_graph_repeated_objects",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/heap_target_process.sql",
            "source_sha256": "e6dc119ff332e00bd847e30c45172809b69fd93bbc3e625282be768db242c90a"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/heap_graph_dump_scope.sql",
            "source_sha256": "4b0db7618d6d3b9db6b371cf8ebe963e88ddfd4738b7115a184fe2cbeae826f9"
          }
        ],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "graph_sample_ts",
          "max_rows",
          "package",
          "process_name",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "heap_graph"
        ]
      },
      "id": "android_memory_v57_ai_diagnostics/heap_graph_size_frequencies",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_memory_v57_ai_diagnostics/heap_graph_size_frequencies.sql",
      "sha256": "c60b6f7f0e33c88e1253e451a558fbe6b7ff44e81a277071db59155aecdd9eb4",
      "signal_patterns": [
        "heap_graph*",
        "hprof*"
      ],
      "skill_id": "android_memory_v57_ai_diagnostics",
      "source": {
        "path": "backend/skills/composite/android_memory_v57_ai_diagnostics.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "bb2e6b53cdde9eef70dca527316ceb2d87cdaed5c609cafd9ec516f76b3cd770"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "prelude.after_eof.memory",
          "prelude.after_eof.views",
          "android.memory.heap_graph.heap_graph_stats",
          "android.memory.heap_graph.class_summary_tree"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "heap_graph_size_frequencies",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/heap_target_process.sql",
            "source_sha256": "e6dc119ff332e00bd847e30c45172809b69fd93bbc3e625282be768db242c90a"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/heap_graph_dump_scope.sql",
            "source_sha256": "4b0db7618d6d3b9db6b371cf8ebe963e88ddfd4738b7115a184fe2cbeae826f9"
          }
        ],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "graph_sample_ts",
          "max_rows",
          "package",
          "process_name",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "android_memory_v57_ai_diagnostics/no_data_contract",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_memory_v57_ai_diagnostics/no_data_contract.sql",
      "sha256": "1bec39cca3afceaf56f85f219469b73a934607e5006a9d30ff91d3754c4947e7",
      "signal_patterns": [],
      "skill_id": "android_memory_v57_ai_diagnostics",
      "source": {
        "path": "backend/skills/composite/android_memory_v57_ai_diagnostics.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "bb2e6b53cdde9eef70dca527316ceb2d87cdaed5c609cafd9ec516f76b3cd770"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "prelude.after_eof.memory",
          "prelude.after_eof.views",
          "android.memory.heap_graph.heap_graph_stats",
          "android.memory.heap_graph.class_summary_tree"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "no_data_contract",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [
          "data_check"
        ],
        "result_references": [
          "data_check"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "android_memory_v57_ai_diagnostics"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "android_process_state_residency/process_state_capability",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_process_state_residency/process_state_capability.sql",
      "sha256": "17a64fe0621ccb50a0f5134ba327c3b447251869f91ae8a3d80afc64388af87f",
      "signal_patterns": [
        "_android_process_state_intervals"
      ],
      "skill_id": "android_process_state_residency",
      "source": {
        "path": "backend/skills/atomic/android_process_state_residency.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "f785279fb41abf9e40451b7089d02655c17180229724e8a28759af866c6347cf"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.process_state"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "process_state_capability",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "android_process_state_residency/process_state_data",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_process_state_residency/process_state_data.sql",
      "sha256": "b1155da78ac52e56e42f313ddf46e0c932fb8356bb6ff512bfcbec44e6b247ef",
      "signal_patterns": [],
      "skill_id": "android_process_state_residency",
      "source": {
        "path": "backend/skills/atomic/android_process_state_residency.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "f785279fb41abf9e40451b7089d02655c17180229724e8a28759af866c6347cf"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.process_state"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "process_state_data",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/process_state_scoped_intervals.sql",
            "source_sha256": "af3414537aa1a703e9b854a6abda6fa0df8ae3488f58c8cf650ecb2647cd802f"
          }
        ],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "process_name",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "android_process_state_residency/process_state_residency",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_process_state_residency/process_state_residency.sql",
      "sha256": "638a86bed999c14a232c810f915974df6a0e0da036b5ade6b99cdd86adf0227f",
      "signal_patterns": [],
      "skill_id": "android_process_state_residency",
      "source": {
        "path": "backend/skills/atomic/android_process_state_residency.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "f785279fb41abf9e40451b7089d02655c17180229724e8a28759af866c6347cf"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.process_state"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "process_state_residency",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/process_state_scoped_intervals.sql",
            "source_sha256": "af3414537aa1a703e9b854a6abda6fa0df8ae3488f58c8cf650ecb2647cd802f"
          }
        ],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "process_name",
          "start_ts",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "android_process_state_residency/process_state_transitions",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_process_state_residency/process_state_transitions.sql",
      "sha256": "ff6e83c407b51cdababf9c40554a06c6d5b039998c003f2c60b5be987f5e436a",
      "signal_patterns": [],
      "skill_id": "android_process_state_residency",
      "source": {
        "path": "backend/skills/atomic/android_process_state_residency.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "f785279fb41abf9e40451b7089d02655c17180229724e8a28759af866c6347cf"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.process_state"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "process_state_transitions",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/process_state_scoped_intervals.sql",
            "source_sha256": "af3414537aa1a703e9b854a6abda6fa0df8ae3488f58c8cf650ecb2647cd802f"
          }
        ],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "max_rows",
          "process_name",
          "start_ts",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "android_process_state_residency/process_state_last_observed",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/android_process_state_residency/process_state_last_observed.sql",
      "sha256": "8fef064d2189c691e1f8506a3eb764a9d57732f2b1563416f95742b1292f6783",
      "signal_patterns": [],
      "skill_id": "android_process_state_residency",
      "source": {
        "path": "backend/skills/atomic/android_process_state_residency.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "f785279fb41abf9e40451b7089d02655c17180229724e8a28759af866c6347cf"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.process_state"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "process_state_last_observed",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/process_state_scoped_intervals.sql",
            "source_sha256": "af3414537aa1a703e9b854a6abda6fa0df8ae3488f58c8cf650ecb2647cd802f"
          }
        ],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "process_name",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "android_process_state_residency"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "anr_analysis/anr_detection",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_analysis/anr_detection.sql",
      "sha256": "94ad5487869c05271283cc6480052981dd6aeca8f4c603ba6bbc6153046dab16",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "anr_analysis",
      "source": {
        "path": "backend/skills/composite/anr_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1fa589ef5136298372b33fb125b7e0ffa15108e83ecabe89690df65f9bf71ed2"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.anrs",
          "android.binder",
          "android.memory.lmk"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "anr_detection",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/anr_matched.sql",
            "source_sha256": "ebabbbbfa0deeee19cf4f894cc04291823185f0a8124440d27b8b75c000b5844"
          }
        ],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "anr_type",
          "package",
          "process_name"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "anr_analysis/trigger_classification",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_analysis/trigger_classification.sql",
      "sha256": "b7974d8a08c7f79c4cca0688e2539d3c33a237752184cbd00e2c94434e3d9f60",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "${process_name}",
        "${process_name}:*",
        "*GC*"
      ],
      "skill_id": "anr_analysis",
      "source": {
        "path": "backend/skills/composite/anr_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1fa589ef5136298372b33fb125b7e0ffa15108e83ecabe89690df65f9bf71ed2"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.anrs",
          "android.binder",
          "android.memory.lmk"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "trigger_classification",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/art_gc_names.sql",
            "source_sha256": "2e50cd240ecb068815a92c13ff38fe2ea843172eece9818b3ed8bfd05f43dfd5"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/anr_matched.sql",
            "source_sha256": "ebabbbbfa0deeee19cf4f894cc04291823185f0a8124440d27b8b75c000b5844"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/anr_classified.sql",
            "source_sha256": "cfe4acd3d54e0e1b366530cca13165eb9060951ded5bd369c081c6eab1d05838"
          }
        ],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "anr_type",
          "package",
          "process_name"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "anr_analysis/system_cpu_health",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_analysis/system_cpu_health.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "7d0c90b0f9d107c78f36f8c47b69bb70eb4fdafe3b2d81829fa0243c97cecc27",
      "signal_patterns": [],
      "skill_id": "anr_analysis",
      "source": {
        "path": "backend/skills/composite/anr_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1fa589ef5136298372b33fb125b7e0ffa15108e83ecabe89690df65f9bf71ed2"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.anrs",
          "android.binder",
          "android.memory.lmk"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "system_cpu_health",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/system_sched_spans.sql",
            "source_sha256": "ebcdcc6f476c4109051e817bcd107b1e45351faea14ff238ba76fb3f53b0b032"
          }
        ],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [
          "anr_ctx"
        ],
        "result_references": [
          "anr_ctx"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "anr_analysis/memory_pressure",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_analysis/memory_pressure.sql",
      "sha256": "6e37ec6343a69380f2b489889ca5a6f21f12a71a58c3b98596634a00977b1eec",
      "signal_patterns": [],
      "skill_id": "anr_analysis",
      "source": {
        "path": "backend/skills/composite/anr_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1fa589ef5136298372b33fb125b7e0ffa15108e83ecabe89690df65f9bf71ed2"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.anrs",
          "android.binder",
          "android.memory.lmk"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "memory_pressure",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [
          "anr_ctx"
        ],
        "result_references": [
          "anr_ctx"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "anr_analysis/io_load",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_analysis/io_load.sql",
      "sha256": "f56c780d57fb2266469766858a524f66494f8c0af5ddac71fbb8d1b27f4b5d88",
      "signal_patterns": [],
      "skill_id": "anr_analysis",
      "source": {
        "path": "backend/skills/composite/anr_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1fa589ef5136298372b33fb125b7e0ffa15108e83ecabe89690df65f9bf71ed2"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.anrs",
          "android.binder",
          "android.memory.lmk"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "io_load",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [
          "anr_ctx"
        ],
        "result_references": [
          "anr_ctx"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "anr_analysis/anr_process_io_wait",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_analysis/anr_process_io_wait.sql",
      "sha256": "3a4430202580fabfc78ff7e1fb745cf086e944480cf6b3add11e5a886b318bf5",
      "signal_patterns": [],
      "skill_id": "anr_analysis",
      "source": {
        "path": "backend/skills/composite/anr_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1fa589ef5136298372b33fb125b7e0ffa15108e83ecabe89690df65f9bf71ed2"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.anrs",
          "android.binder",
          "android.memory.lmk"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "anr_process_io_wait",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/io_blocked_function_families.sql",
            "source_sha256": "8d45506b0b20c30c432f555da5a21e293f3d290c55059f1cd3f508f77df72bb0"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/system_thread_state_spans.sql",
            "source_sha256": "40a17843f23e9cd7a249735450ff58accb11c2ecb13ac8c22f3f9ff31bcadaa1"
          }
        ],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [
          "anr_ctx"
        ],
        "result_references": [
          "anr_ctx"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "anr_analysis/system_freeze_check",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_analysis/system_freeze_check.sql",
      "sha256": "20b2ed440603acb39b00ad615d4d965e1ee33def2a8126b5810923c53eb68a7b",
      "signal_patterns": [
        "system_server"
      ],
      "skill_id": "anr_analysis",
      "source": {
        "path": "backend/skills/composite/anr_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1fa589ef5136298372b33fb125b7e0ffa15108e83ecabe89690df65f9bf71ed2"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.anrs",
          "android.binder",
          "android.memory.lmk"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "system_freeze_check",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [
          "anr_ctx"
        ],
        "result_references": [
          "anr_ctx"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "anr_analysis/anr_overview",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_analysis/anr_overview.sql",
      "sha256": "e8c163511c5ff0300989f0ce95b379468da1115b0d427653131e30832ed57881",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "${process_name}",
        "${process_name}:*",
        "*GC*"
      ],
      "skill_id": "anr_analysis",
      "source": {
        "path": "backend/skills/composite/anr_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1fa589ef5136298372b33fb125b7e0ffa15108e83ecabe89690df65f9bf71ed2"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.anrs",
          "android.binder",
          "android.memory.lmk"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "anr_overview",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/art_gc_names.sql",
            "source_sha256": "2e50cd240ecb068815a92c13ff38fe2ea843172eece9818b3ed8bfd05f43dfd5"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/anr_matched.sql",
            "source_sha256": "ebabbbbfa0deeee19cf4f894cc04291823185f0a8124440d27b8b75c000b5844"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/anr_classified.sql",
            "source_sha256": "cfe4acd3d54e0e1b366530cca13165eb9060951ded5bd369c081c6eab1d05838"
          }
        ],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "anr_type",
          "package",
          "process_name"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "anr_analysis/get_anr_events",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_analysis/get_anr_events.sql",
      "sha256": "bf988e2a06302f50c2c9518dac3d6fabb9a046cac5fe6a81682b1ff62592de33",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "${process_name}",
        "${process_name}:*",
        "*GC*"
      ],
      "skill_id": "anr_analysis",
      "source": {
        "path": "backend/skills/composite/anr_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1fa589ef5136298372b33fb125b7e0ffa15108e83ecabe89690df65f9bf71ed2"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.anrs",
          "android.binder",
          "android.memory.lmk"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "get_anr_events",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/art_gc_names.sql",
            "source_sha256": "2e50cd240ecb068815a92c13ff38fe2ea843172eece9818b3ed8bfd05f43dfd5"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/anr_matched.sql",
            "source_sha256": "ebabbbbfa0deeee19cf4f894cc04291823185f0a8124440d27b8b75c000b5844"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/anr_classified.sql",
            "source_sha256": "cfe4acd3d54e0e1b366530cca13165eb9060951ded5bd369c081c6eab1d05838"
          }
        ],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "anr_type",
          "package",
          "process_name"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "anr_analysis/top_cpu_processes",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_analysis/top_cpu_processes.sql",
      "sha256": "52b0ed50610b0f926bf12073e8458b3111b4cf5858ee0b1e8331ab97e08241ea",
      "signal_patterns": [],
      "skill_id": "anr_analysis",
      "source": {
        "path": "backend/skills/composite/anr_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1fa589ef5136298372b33fb125b7e0ffa15108e83ecabe89690df65f9bf71ed2"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.anrs",
          "android.binder",
          "android.memory.lmk"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "top_cpu_processes",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [
          "anr_ctx"
        ],
        "result_references": [
          "anr_ctx"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "anr_analysis"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "anr_context_in_range/root",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_context_in_range/query.sql",
      "sha256": "b1eea733019cb090d683c4e972b75a09cac1e81a3fd3aeb7df65eff41b49525f",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "anr_context_in_range",
      "source": {
        "path": "backend/skills/atomic/anr_context_in_range.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "4a14d85ad7cd54b07f817c9c76948eefd985a4e2af90e0864f7f4360abc171d3"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.anrs"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/anr_matched.sql",
            "source_sha256": "ebabbbbfa0deeee19cf4f894cc04291823185f0a8124440d27b8b75c000b5844"
          }
        ],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "anr_type",
          "package",
          "process_name"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "anr_context_in_range"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "anr_detail/system_context_window",
      "identity": {
        "aliases": [
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_detail/system_context_window.sql",
      "process_scope": {
        "role": "identity_metadata"
      },
      "sha256": "6682aa9750775de41f688ddbc7a41bcb94406c6bd893d2dc46816ebd91454aa5",
      "signal_patterns": [],
      "skill_id": "anr_detail",
      "source": {
        "path": "backend/skills/composite/anr_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "74e651ef4fa4d3949dacf7c4db5b28bd3f522b40e1ff76c40cb2829ea17d44a5"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder",
          "linux.cpu.frequency",
          "android.monitor_contention"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "system_context_window",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "anr_ts",
          "timeout_ns"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "anr_detail/anr_info",
      "identity": {
        "aliases": [
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_detail/anr_info.sql",
      "process_scope": {
        "role": "identity_metadata"
      },
      "sha256": "e332ef911b1e0f3ae4b80a96721863c74c4450344511423135ff5a176d0ce3a4",
      "signal_patterns": [],
      "skill_id": "anr_detail",
      "source": {
        "path": "backend/skills/composite/anr_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "74e651ef4fa4d3949dacf7c4db5b28bd3f522b40e1ff76c40cb2829ea17d44a5"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder",
          "linux.cpu.frequency",
          "android.monitor_contention"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "anr_info",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "anr_dur_ms",
          "anr_ts",
          "anr_type",
          "error_id",
          "perfetto_end",
          "perfetto_start",
          "process_name",
          "timeout_ns"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "anr_detail/main_thread_quadrant",
      "identity": {
        "aliases": [
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_detail/main_thread_quadrant.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "4af2247f3d7765074ef19abe8b16cfd932727423e1e74faaacdebce417892996",
      "signal_patterns": [
        "${process_name}:*"
      ],
      "skill_id": "anr_detail",
      "source": {
        "path": "backend/skills/composite/anr_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "74e651ef4fa4d3949dacf7c4db5b28bd3f522b40e1ff76c40cb2829ea17d44a5"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder",
          "linux.cpu.frequency",
          "android.monitor_contention"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "main_thread_quadrant",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/system_sched_spans.sql",
            "source_sha256": "ebcdcc6f476c4109051e817bcd107b1e45351faea14ff238ba76fb3f53b0b032"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/system_thread_state_spans.sql",
            "source_sha256": "40a17843f23e9cd7a249735450ff58accb11c2ecb13ac8c22f3f9ff31bcadaa1"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          }
        ],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "anr_ts",
          "pid",
          "process_name",
          "timeout_ns",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "anr_detail/render_thread_analysis",
      "identity": {
        "aliases": [
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_detail/render_thread_analysis.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "be772f96bdadafcd54b97d127e89dec8b48ccd06a858c81145119e1ba793fa85",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*",
        "%DrawFrame%",
        "%dequeueBuffer%",
        "%nSyncDraw%",
        "%syncFrameState%",
        "RenderThread"
      ],
      "skill_id": "anr_detail",
      "source": {
        "path": "backend/skills/composite/anr_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "74e651ef4fa4d3949dacf7c4db5b28bd3f522b40e1ff76c40cb2829ea17d44a5"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder",
          "linux.cpu.frequency",
          "android.monitor_contention"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "render_thread_analysis",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          }
        ],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "anr_ts",
          "pid",
          "process_name",
          "timeout_ns",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "anr_detail/lock_contention",
      "identity": {
        "aliases": [
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_detail/lock_contention.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "context_fields": {
          "peer_context": [
            "blocking_method",
            "blocking_thread_name",
            "waiter_count"
          ]
        },
        "role": "target"
      },
      "sha256": "5f8c1c95bbf74226095a11eced50c04929c6e64979e939b73158ace9af3183d5",
      "signal_patterns": [
        "${process_name}"
      ],
      "skill_id": "anr_detail",
      "source": {
        "path": "backend/skills/composite/anr_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "74e651ef4fa4d3949dacf7c4db5b28bd3f522b40e1ff76c40cb2829ea17d44a5"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder",
          "linux.cpu.frequency",
          "android.monitor_contention"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "lock_contention",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          }
        ],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "anr_ts",
          "process_name",
          "timeout_ns"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "anr_detail/app_freeze_check",
      "identity": {
        "aliases": [
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_detail/app_freeze_check.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "5b023f29dec19160559c7c0ee37786f34b661316aa755af257b490f694d04c5a",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*",
        "Binder:%",
        "RenderThread"
      ],
      "skill_id": "anr_detail",
      "source": {
        "path": "backend/skills/composite/anr_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "74e651ef4fa4d3949dacf7c4db5b28bd3f522b40e1ff76c40cb2829ea17d44a5"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder",
          "linux.cpu.frequency",
          "android.monitor_contention"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "app_freeze_check",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          }
        ],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "anr_ts",
          "pid",
          "process_name",
          "timeout_ns",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "anr_detail/wakeup_chain",
      "identity": {
        "aliases": [
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_detail/wakeup_chain.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "context_fields": {
          "peer_context": [
            "waker_thread",
            "waker_process"
          ]
        },
        "role": "target"
      },
      "sha256": "f242830f1f38a15ad368c21fa9f996d0cf750c17be9b1ff530da4ee3c5305272",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "anr_detail",
      "source": {
        "path": "backend/skills/composite/anr_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "74e651ef4fa4d3949dacf7c4db5b28bd3f522b40e1ff76c40cb2829ea17d44a5"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder",
          "linux.cpu.frequency",
          "android.monitor_contention"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "wakeup_chain",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/system_thread_state_spans.sql",
            "source_sha256": "40a17843f23e9cd7a249735450ff58accb11c2ecb13ac8c22f3f9ff31bcadaa1"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          }
        ],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "anr_ts",
          "pid",
          "process_name",
          "timeout_ns",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "anr_detail/thread_evidence_availability",
      "identity": {
        "aliases": [
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_detail/thread_evidence_availability.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "8730c72c1d308a98026b083762ae8715e11f32c6a83433b0938eb3d96175bd1b",
      "signal_patterns": [
        "slice",
        "thread_state",
        "thread_track"
      ],
      "skill_id": "anr_detail",
      "source": {
        "path": "backend/skills/composite/anr_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "74e651ef4fa4d3949dacf7c4db5b28bd3f522b40e1ff76c40cb2829ea17d44a5"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder",
          "linux.cpu.frequency",
          "android.monitor_contention"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "thread_evidence_availability",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "anr_detail/direct_blocker_evidence_gap",
      "identity": {
        "aliases": [
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_detail/direct_blocker_evidence_gap.sql",
      "process_scope": {
        "role": "identity_metadata"
      },
      "sha256": "7d50aaf43c64aabef1f3786770c7b95fb9ef3e0635c12183cfa6b9685700a13d",
      "signal_patterns": [],
      "skill_id": "anr_detail",
      "source": {
        "path": "backend/skills/composite/anr_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "74e651ef4fa4d3949dacf7c4db5b28bd3f522b40e1ff76c40cb2829ea17d44a5"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder",
          "linux.cpu.frequency",
          "android.monitor_contention"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "direct_blocker_evidence_gap",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "anr_detail/direct_blocker_classification",
      "identity": {
        "aliases": [
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_detail/direct_blocker_classification.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "eca0f4fbe7484367caeb25f89fab38403bf1dada2da264265e91cb22484fc1f6",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "anr_detail",
      "source": {
        "path": "backend/skills/composite/anr_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "74e651ef4fa4d3949dacf7c4db5b28bd3f522b40e1ff76c40cb2829ea17d44a5"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder",
          "linux.cpu.frequency",
          "android.monitor_contention"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "direct_blocker_classification",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          }
        ],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "anr_ts",
          "pid",
          "process_name",
          "timeout_ns",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "anr_detail/direct_blocker_slice_evidence_gap",
      "identity": {
        "aliases": [
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_detail/direct_blocker_slice_evidence_gap.sql",
      "process_scope": {
        "role": "identity_metadata"
      },
      "sha256": "50115a3de82a20ba8eafe57eb67e452455f89fc7b50792c18d771a4ddbf21c6d",
      "signal_patterns": [],
      "skill_id": "anr_detail",
      "source": {
        "path": "backend/skills/composite/anr_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "74e651ef4fa4d3949dacf7c4db5b28bd3f522b40e1ff76c40cb2829ea17d44a5"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder",
          "linux.cpu.frequency",
          "android.monitor_contention"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "direct_blocker_slice_evidence_gap",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "anr_detail/direct_blocker_slice_classification",
      "identity": {
        "aliases": [
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_detail/direct_blocker_slice_classification.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "e614f39b98316000ce272bfc1a26dfe0bf6856b2306b4c2a8bc9dcefacd5e869",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*",
        "*GC*",
        "RenderThread"
      ],
      "skill_id": "anr_detail",
      "source": {
        "path": "backend/skills/composite/anr_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "74e651ef4fa4d3949dacf7c4db5b28bd3f522b40e1ff76c40cb2829ea17d44a5"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder",
          "linux.cpu.frequency",
          "android.monitor_contention"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "direct_blocker_slice_classification",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/art_gc_names.sql",
            "source_sha256": "2e50cd240ecb068815a92c13ff38fe2ea843172eece9818b3ed8bfd05f43dfd5"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          }
        ],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "anr_ts",
          "pid",
          "process_name",
          "timeout_ns",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "anr_detail/logcat_availability",
      "identity": {
        "aliases": [
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_detail/logcat_availability.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "254d48b48f2f0c43166eaa4cb841398178f382414d4805f10d180f127bb7c58d",
      "signal_patterns": [
        "android_logs"
      ],
      "skill_id": "anr_detail",
      "source": {
        "path": "backend/skills/composite/anr_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "74e651ef4fa4d3949dacf7c4db5b28bd3f522b40e1ff76c40cb2829ea17d44a5"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder",
          "linux.cpu.frequency",
          "android.monitor_contention"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "logcat_availability",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "anr_detail/anr_logcat_evidence_gap",
      "identity": {
        "aliases": [
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_detail/anr_logcat_evidence_gap.sql",
      "process_scope": {
        "role": "identity_metadata"
      },
      "sha256": "f9383073d501e3ed8dbb42450421e224ed51c1a2b5a7ac9afbe5ed5b44f3667b",
      "signal_patterns": [],
      "skill_id": "anr_detail",
      "source": {
        "path": "backend/skills/composite/anr_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "74e651ef4fa4d3949dacf7c4db5b28bd3f522b40e1ff76c40cb2829ea17d44a5"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder",
          "linux.cpu.frequency",
          "android.monitor_contention"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "anr_logcat_evidence_gap",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "error_id"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "anr_detail/anr_logcat_context",
      "identity": {
        "aliases": [
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_detail/anr_logcat_context.sql",
      "process_scope": {
        "limitations": [
          "Logcat rows are correlated by event identifiers or message text and do not establish an exact process instance."
        ],
        "role": "global_context"
      },
      "sha256": "2bbca879eb7feb5d24eff99c1b4a38286ac45a3cdd2c2bc79b13ebaffa9079ea",
      "signal_patterns": [
        "*GC*"
      ],
      "skill_id": "anr_detail",
      "source": {
        "path": "backend/skills/composite/anr_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "74e651ef4fa4d3949dacf7c4db5b28bd3f522b40e1ff76c40cb2829ea17d44a5"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder",
          "linux.cpu.frequency",
          "android.monitor_contention"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "anr_logcat_context",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/art_gc_names.sql",
            "source_sha256": "2e50cd240ecb068815a92c13ff38fe2ea843172eece9818b3ed8bfd05f43dfd5"
          }
        ],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "anr_ts",
          "component",
          "error_id",
          "intent",
          "process_name",
          "timeout_ns"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "anr_detail"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "anr_main_thread_blocking/main_thread_state",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_main_thread_blocking/main_thread_state.sql",
      "sha256": "3e19e0a76a9246b255e8b083150849a8a56455062d7cec2c07c6a1b753aa42b4",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "anr_main_thread_blocking",
      "source": {
        "path": "backend/skills/atomic/anr_main_thread_blocking.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "e19ece9595a2bf2bd22ead9b8e4c2236e061a672b7f6e76c0c5cd4cf94478349"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder",
          "android.monitor_contention"
        ],
        "drops": [],
        "required_tables": [
          "thread_state",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "main_thread_state",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "anr_ts",
          "end_ts",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "anr_main_thread_blocking/blocked_functions",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_main_thread_blocking/blocked_functions.sql",
      "sha256": "44619c236275a08934a4021c5a543e8e5af917b0edf4a8f5dc52167ffb8eb7fd",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "anr_main_thread_blocking",
      "source": {
        "path": "backend/skills/atomic/anr_main_thread_blocking.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "e19ece9595a2bf2bd22ead9b8e4c2236e061a672b7f6e76c0c5cd4cf94478349"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder",
          "android.monitor_contention"
        ],
        "drops": [],
        "required_tables": [
          "thread_state",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "blocked_functions",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "anr_ts",
          "end_ts",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "anr_main_thread_blocking/wakeup_chain",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_main_thread_blocking/wakeup_chain.sql",
      "sha256": "d7346611457d58e43c5ef0f810b345a22256a435111c13b14e5b71916b280460",
      "signal_patterns": [
        "${process_name}:*"
      ],
      "skill_id": "anr_main_thread_blocking",
      "source": {
        "path": "backend/skills/atomic/anr_main_thread_blocking.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "e19ece9595a2bf2bd22ead9b8e4c2236e061a672b7f6e76c0c5cd4cf94478349"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder",
          "android.monitor_contention"
        ],
        "drops": [],
        "required_tables": [
          "thread_state",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "wakeup_chain",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/system_thread_state_spans.sql",
            "source_sha256": "40a17843f23e9cd7a249735450ff58accb11c2ecb13ac8c22f3f9ff31bcadaa1"
          }
        ],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "anr_ts",
          "end_ts",
          "min_wait_ms",
          "offset",
          "process_name",
          "start_ts",
          "top_n"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "anr_main_thread_blocking/binder_blocking",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_main_thread_blocking/binder_blocking.sql",
      "sha256": "6c3bd9d0c3c9af072070d91a9d5def03719ea2afffff4bebd0f2d2082f7a03a9",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "anr_main_thread_blocking",
      "source": {
        "path": "backend/skills/atomic/anr_main_thread_blocking.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "e19ece9595a2bf2bd22ead9b8e4c2236e061a672b7f6e76c0c5cd4cf94478349"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder",
          "android.monitor_contention"
        ],
        "drops": [],
        "required_tables": [
          "thread_state",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "binder_blocking",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "anr_ts",
          "end_ts",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "anr_main_thread_blocking/lock_contention",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/anr_main_thread_blocking/lock_contention.sql",
      "sha256": "4d73c25d95657c7ee4a3e11b690f9eef8ea958d5ea6f29d743cc7a8a53cd35d6",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*",
        "*futex*"
      ],
      "skill_id": "anr_main_thread_blocking",
      "source": {
        "path": "backend/skills/atomic/anr_main_thread_blocking.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "e19ece9595a2bf2bd22ead9b8e4c2236e061a672b7f6e76c0c5cd4cf94478349"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder",
          "android.monitor_contention"
        ],
        "drops": [],
        "required_tables": [
          "thread_state",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "lock_contention",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "anr_ts",
          "end_ts",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "anr_main_thread_blocking"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "frame_timeline"
        ]
      },
      "id": "app_frame_production/app_production_stats",
      "identity": {
        "aliases": [
          "package",
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/app_frame_production/app_production_stats.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "7cecf290b4b0b8b2300ae153bd10e201229d541ba7bb0134f277d205108a19df",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "app_frame_production",
      "source": {
        "path": "backend/skills/atomic/app_frame_production.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "f7c24d6aa56cc29422e948867cc203415f06ff4182964dd3fc594aa23a3be29a"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [
          "actual_frame_timeline_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "app_production_stats",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "app_frame_production"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "app_lifecycle_in_range/root",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/app_lifecycle_in_range/query.sql",
      "sha256": "df11b13cde7ad692864b1207ee57bf3af46e5a28b2b922698b0e6228fe2a6519",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*Fragment*",
        "*activityPause*",
        "*activityResume*",
        "*activityStart*",
        "*bindApplication*",
        "*inflate*",
        "*onCreate*",
        "*onDestroy*",
        "*onPause*",
        "*onResume*",
        "*onStart*",
        "*onStop*",
        "*performCreate*",
        "completed:*",
        "launching:*"
      ],
      "skill_id": "app_lifecycle_in_range",
      "source": {
        "path": "backend/skills/atomic/app_lifecycle_in_range.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "7ffba4598c01c6d56288d957575a0473a0d5fc051662a7adacae279e95b9b694"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "app_lifecycle_in_range"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "app_process_starts_summary/process_starts",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/app_process_starts_summary/process_starts.sql",
      "sha256": "b3e74e0b8c33d2db5750681b88284a8c77c375c1e7530abfc1aac69051038512",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "app_process_starts_summary",
      "source": {
        "path": "backend/skills/atomic/app_process_starts_summary.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "b6c52e29a1056ff902bdfb67ff8c9e187457aea4660d8ac95764a4b4c8907df4"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.app_process_starts"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "process_starts",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "app_process_starts_summary"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "art_module/gc_overview",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/art_module/gc_overview.sql",
      "sha256": "d68dd4fa706ee21333d9541848f2441d7640c00136b543d2cdadcf6752a20a17",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*GC*"
      ],
      "skill_id": "art_module",
      "source": {
        "path": "backend/skills/modules/framework/art_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "420e56403b3df38fd4f2d2f938b611c484252d3bc7f733ba7b956813c7a02fcf"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gc_overview",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/art_gc_names.sql",
            "source_sha256": "2e50cd240ecb068815a92c13ff38fe2ea843172eece9818b3ed8bfd05f43dfd5"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/memory_gc_events.sql",
            "source_sha256": "f682124224f533bdb40865b3a859b2d702a90fdc6899dc377b307e0c4e33d569"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "art_module/gc_totals",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/art_module/gc_totals.sql",
      "sha256": "1a26ce2c06851abdc4152b35d774fb40ed7f801d6754e1d7879db800cbc76579",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*GC*"
      ],
      "skill_id": "art_module",
      "source": {
        "path": "backend/skills/modules/framework/art_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "420e56403b3df38fd4f2d2f938b611c484252d3bc7f733ba7b956813c7a02fcf"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gc_totals",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/art_gc_names.sql",
            "source_sha256": "2e50cd240ecb068815a92c13ff38fe2ea843172eece9818b3ed8bfd05f43dfd5"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/memory_gc_events.sql",
            "source_sha256": "f682124224f533bdb40865b3a859b2d702a90fdc6899dc377b307e0c4e33d569"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "art_module/gc_events",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/art_module/gc_events.sql",
      "sha256": "909cad2a729f2bdd81d4ab9cfd44098f4fa5e2a61c719b88bea802b51899e763",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*GC*"
      ],
      "skill_id": "art_module",
      "source": {
        "path": "backend/skills/modules/framework/art_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "420e56403b3df38fd4f2d2f938b611c484252d3bc7f733ba7b956813c7a02fcf"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gc_events",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/art_gc_names.sql",
            "source_sha256": "2e50cd240ecb068815a92c13ff38fe2ea843172eece9818b3ed8bfd05f43dfd5"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/memory_gc_events.sql",
            "source_sha256": "f682124224f533bdb40865b3a859b2d702a90fdc6899dc377b307e0c4e33d569"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "art_module/gc_during_main_thread",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/art_module/gc_during_main_thread.sql",
      "sha256": "3098c82e66fdae28c7627b8f88a27a40d8fe3628f43a93c0894b302b96e403ba",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*GC*"
      ],
      "skill_id": "art_module",
      "source": {
        "path": "backend/skills/modules/framework/art_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "420e56403b3df38fd4f2d2f938b611c484252d3bc7f733ba7b956813c7a02fcf"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gc_during_main_thread",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/art_gc_names.sql",
            "source_sha256": "2e50cd240ecb068815a92c13ff38fe2ea843172eece9818b3ed8bfd05f43dfd5"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/memory_gc_events.sql",
            "source_sha256": "f682124224f533bdb40865b3a859b2d702a90fdc6899dc377b307e0c4e33d569"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "art_module/jit_events",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/art_module/jit_events.sql",
      "sha256": "f35db70f6a546d5253d08d1c796eec2f5fde7ea99c3d82a20d6f3889a00ae250",
      "signal_patterns": [
        "%JIT%",
        "%compile%"
      ],
      "skill_id": "art_module",
      "source": {
        "path": "backend/skills/modules/framework/art_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "420e56403b3df38fd4f2d2f938b611c484252d3bc7f733ba7b956813c7a02fcf"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "jit_events",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "art_module"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "battery_charge_timeline/battery_samples",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/battery_charge_timeline/battery_samples.sql",
      "sha256": "b45522ee4f849a6ce26c14be83dfee9cfe7cdbd044512b3fd809a8d66f5adbcb",
      "signal_patterns": [],
      "skill_id": "battery_charge_timeline",
      "source": {
        "path": "backend/skills/atomic/battery_charge_timeline.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "f2c833e0011fe26b5fa5876a09017049993e4ccd8fb399900e18e730417a037b"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.battery"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "battery_samples",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "battery_charge_timeline"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "battery_doze_state_timeline/deep_idle_intervals",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/battery_doze_state_timeline/deep_idle_intervals.sql",
      "sha256": "6cde876f6bc9e66a68084d62c39fb2a2a8ad80cefe910a4d161b7946268f0ee2",
      "signal_patterns": [],
      "skill_id": "battery_doze_state_timeline",
      "source": {
        "path": "backend/skills/atomic/battery_doze_state_timeline.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "76538da9dab1b6f5e68441be298de8fa40633dbe1e8b0cf79d547d49c1f1e4a1"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.battery.doze"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "deep_idle_intervals",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "battery_doze_state_timeline/light_idle_intervals",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/battery_doze_state_timeline/light_idle_intervals.sql",
      "sha256": "04293aad59c92ae0a6595037860fe87e6b1d6a1716354c729d851ad58289aa75",
      "signal_patterns": [],
      "skill_id": "battery_doze_state_timeline",
      "source": {
        "path": "backend/skills/atomic/battery_doze_state_timeline.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "76538da9dab1b6f5e68441be298de8fa40633dbe1e8b0cf79d547d49c1f1e4a1"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.battery.doze"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "light_idle_intervals",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "battery_doze_state_timeline"
}

{
  "queries": [],
  "schema_version": 1,
  "skill_id": "battery_drain_attribution"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "battery_drain_rate_summary/drain_rate",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/battery_drain_rate_summary/drain_rate.sql",
      "sha256": "3a3c90f95f45fe6a4da9e8c03378b193bde9b0e073c0fc9f894bd26e95b69f21",
      "signal_patterns": [],
      "skill_id": "battery_drain_rate_summary",
      "source": {
        "path": "backend/skills/atomic/battery_drain_rate_summary.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "f5a1df9c8222d32c6942df42bb1bbde8dc81f44d1b7cd23ea41aed8897bda582"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.battery"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "drain_rate",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "battery_drain_rate_summary"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "binder_analysis/check_binder",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/binder_analysis/check_binder.sql",
      "sha256": "0ebecb07baeaf21ae8d0e7ac560d62d29f06601c633169dd6f99dc4c6d09e238",
      "signal_patterns": [],
      "skill_id": "binder_analysis",
      "source": {
        "path": "backend/skills/composite/binder_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "fc34e062a7ce8185abceac60b9171ac039d0e631ee0ef1646f3d6ef0369cbeee"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder",
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "check_binder",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "binder_analysis/get_process",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/binder_analysis/get_process.sql",
      "sha256": "3fd3c395683bafd067ec8555e2425c8f1736270c92e25da7c67f9253a9161ccc",
      "signal_patterns": [],
      "skill_id": "binder_analysis",
      "source": {
        "path": "backend/skills/composite/binder_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "fc34e062a7ce8185abceac60b9171ac039d0e631ee0ef1646f3d6ef0369cbeee"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder",
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "get_process",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "binder_analysis/binder_overview",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/binder_analysis/binder_overview.sql",
      "sha256": "060d1b1b659d630670c8bab49e8f0f137df19c3b95d5cd05459fa900d2e6df17",
      "signal_patterns": [],
      "skill_id": "binder_analysis",
      "source": {
        "path": "backend/skills/composite/binder_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "fc34e062a7ce8185abceac60b9171ac039d0e631ee0ef1646f3d6ef0369cbeee"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder",
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "binder_overview",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "slow_binder_critical_ms",
          "slow_binder_warning_ms",
          "start_ts"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "binder_analysis/outgoing_by_interface",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/binder_analysis/outgoing_by_interface.sql",
      "sha256": "17ccbef9e9416bd57aad5d66b27c760f06af4a1cfc7f53d77de7d51a8a14b56d",
      "signal_patterns": [],
      "skill_id": "binder_analysis",
      "source": {
        "path": "backend/skills/composite/binder_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "fc34e062a7ce8185abceac60b9171ac039d0e631ee0ef1646f3d6ef0369cbeee"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder",
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "outgoing_by_interface",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "binder_analysis/main_thread_sync_binder",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/binder_analysis/main_thread_sync_binder.sql",
      "sha256": "79332acd35bccb7e066cd168beea2e31e707509848a78e8bb6ebd52e1dc560f4",
      "signal_patterns": [],
      "skill_id": "binder_analysis",
      "source": {
        "path": "backend/skills/composite/binder_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "fc34e062a7ce8185abceac60b9171ac039d0e631ee0ef1646f3d6ef0369cbeee"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder",
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "main_thread_sync_binder",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "slow_binder_critical_ms",
          "slow_binder_warning_ms",
          "start_ts"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "binder_analysis/binder_blocking_analysis",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/binder_analysis/binder_blocking_analysis.sql",
      "sha256": "954a31da75079e5746dfdd3e164eadbc97c735000003ac6ecd7cd0e267e604fe",
      "signal_patterns": [],
      "skill_id": "binder_analysis",
      "source": {
        "path": "backend/skills/composite/binder_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "fc34e062a7ce8185abceac60b9171ac039d0e631ee0ef1646f3d6ef0369cbeee"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder",
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "binder_blocking_analysis",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "binder_analysis/server_response_analysis",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/binder_analysis/server_response_analysis.sql",
      "sha256": "1dafeadebb9f8537f85c7986203fa30255f0ac7233c3b8ad9935a396b5778e8e",
      "signal_patterns": [],
      "skill_id": "binder_analysis",
      "source": {
        "path": "backend/skills/composite/binder_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "fc34e062a7ce8185abceac60b9171ac039d0e631ee0ef1646f3d6ef0369cbeee"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder",
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "server_response_analysis",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "binder_analysis/binder_frame_correlation",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/binder_analysis/binder_frame_correlation.sql",
      "sha256": "6b0ea0f648476eb8c3cb15f7fe71ce14abd1975557c31787a220d7186e8bcd54",
      "signal_patterns": [
        "${target_process.data[0].process_name}"
      ],
      "skill_id": "binder_analysis",
      "source": {
        "path": "backend/skills/composite/binder_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "fc34e062a7ce8185abceac60b9171ac039d0e631ee0ef1646f3d6ef0369cbeee"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder",
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "binder_frame_correlation",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "binder_analysis/incoming_calls",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/binder_analysis/incoming_calls.sql",
      "sha256": "fc5d5421799dd2f7d0908212ee275f42f738c18001f45eebdf02d877a184647c",
      "signal_patterns": [],
      "skill_id": "binder_analysis",
      "source": {
        "path": "backend/skills/composite/binder_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "fc34e062a7ce8185abceac60b9171ac039d0e631ee0ef1646f3d6ef0369cbeee"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder",
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "incoming_calls",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "binder_analysis"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "binder_blocking_in_range/root",
      "identity": {
        "aliases": [
          "package"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/binder_blocking_in_range/query.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "context_fields": {
          "peer_context": [
            "server_process",
            "interface",
            "server_exec_ms"
          ]
        },
        "role": "target"
      },
      "sha256": "172356f64e6d0946dae8adecaad60ebc619682cfa96e2a26ef5e3e6409c3dffa",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "binder_blocking_in_range",
      "source": {
        "path": "backend/skills/atomic/binder_blocking_in_range.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "59002799db07e79a59076a178cd87477088d4cd4bc9e2c05b481209ccb7d16a3"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "binder_blocking_in_range"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "binder_detail/binder_info",
      "identity": {
        "aliases": [
          "process_name",
          "package"
        ],
        "minConfidence": 50,
        "policy": "required",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/binder_detail/binder_info.sql",
      "sha256": "265c4836d457493a4ddd1b0c401d965164a0388e441c27227c189d8f3edb2544",
      "signal_patterns": [],
      "skill_id": "binder_detail",
      "source": {
        "path": "backend/skills/composite/binder_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "eeadbc879f3b3e4118c66913d5a022ebec45f310e3ea34a03306d58cb80b9141"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "binder_info",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "aidl_name",
          "binder_end_ts",
          "binder_ts",
          "dur_ms",
          "perfetto_end",
          "perfetto_start",
          "process_name",
          "server_process"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "binder_detail/cpu_core_analysis",
      "identity": {
        "aliases": [
          "process_name",
          "package"
        ],
        "minConfidence": 50,
        "policy": "required",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/binder_detail/cpu_core_analysis.sql",
      "sha256": "22e612f2f83d9983cd25ae557148c9bf38dc8875315fd616c41c013e51f20332",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "binder_detail",
      "source": {
        "path": "backend/skills/composite/binder_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "eeadbc879f3b3e4118c66913d5a022ebec45f310e3ea34a03306d58cb80b9141"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [
          "_cpu_topology"
        ],
        "setup_queries": [
          "cpu_topology_view/create_topology_view"
        ]
      },
      "step_id": "cpu_core_analysis",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "binder_end_ts",
          "binder_ts",
          "dur_ms",
          "process_name"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "binder_detail/quadrant_analysis",
      "identity": {
        "aliases": [
          "process_name",
          "package"
        ],
        "minConfidence": 50,
        "policy": "required",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/binder_detail/quadrant_analysis.sql",
      "sha256": "21635ac3f38fc90613c6acc46b0d208225fbe5691323e8f1c8cff3f8f4e62722",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "binder_detail",
      "source": {
        "path": "backend/skills/composite/binder_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "eeadbc879f3b3e4118c66913d5a022ebec45f310e3ea34a03306d58cb80b9141"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [
          "_cpu_topology"
        ],
        "setup_queries": [
          "cpu_topology_view/create_topology_view"
        ]
      },
      "step_id": "quadrant_analysis",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "binder_end_ts",
          "binder_ts",
          "process_name"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "binder_detail/blocking_analysis",
      "identity": {
        "aliases": [
          "process_name",
          "package"
        ],
        "minConfidence": 50,
        "policy": "required",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/binder_detail/blocking_analysis.sql",
      "sha256": "a97f41f4a09b7f46207fe6df7b69f1376b3fd5ca570d281a9d84465aba9dd10a",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "binder_detail",
      "source": {
        "path": "backend/skills/composite/binder_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "eeadbc879f3b3e4118c66913d5a022ebec45f310e3ea34a03306d58cb80b9141"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "blocking_analysis",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "binder_end_ts",
          "binder_ts",
          "process_name"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "binder_detail"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "binder_in_range/root",
      "identity": {
        "aliases": [
          "package"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/binder_in_range/query.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "context_fields": {
          "peer_context": [
            "server_process"
          ]
        },
        "role": "target"
      },
      "sha256": "8a69fd18c466f70dc7c402e736e3a95f13f91788eba4f798e3ed1933a05e32f4",
      "signal_patterns": [],
      "skill_id": "binder_in_range",
      "source": {
        "path": "backend/skills/atomic/binder_in_range.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "88af485b52bd4fc3a754df61300a43d34daf1c875e9870312a031e7e3595670b"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "binder_in_range"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "binder_module/binder_summary",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/binder_module/binder_summary.sql",
      "sha256": "8a3a76b9d282a5e544c53c3dfd6981bc4ae3175450f09539245bfa44be79ba85",
      "signal_patterns": [],
      "skill_id": "binder_module",
      "source": {
        "path": "backend/skills/modules/kernel/binder_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "e374d828a42b45b2f0c2de0b02ca10fd40049073b3e8b52aedb4724592469f73"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "binder_summary",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "binder_module/long_sync_calls",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/binder_module/long_sync_calls.sql",
      "sha256": "29c25a3a0ca6c55cac7a855b3b1715ac32fa54c427780245ca6f49386c34283a",
      "signal_patterns": [],
      "skill_id": "binder_module",
      "source": {
        "path": "backend/skills/modules/kernel/binder_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "e374d828a42b45b2f0c2de0b02ca10fd40049073b3e8b52aedb4724592469f73"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "long_sync_calls",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "binder_module/blocking_analysis",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/binder_module/blocking_analysis.sql",
      "sha256": "0d8f88eebf2dcd7c64151d852576174220ef8e833306b56375af24aeb3e5d9fb",
      "signal_patterns": [],
      "skill_id": "binder_module",
      "source": {
        "path": "backend/skills/modules/kernel/binder_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "e374d828a42b45b2f0c2de0b02ca10fd40049073b3e8b52aedb4724592469f73"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "blocking_analysis",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "binder_module"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "binder_root_cause/slow_binder_breakdown",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/binder_root_cause/slow_binder_breakdown.sql",
      "sha256": "19e81abc565e33d01d259ef6aa3f793061b79a5fc5466249c3225d3b4a831a13",
      "signal_patterns": [],
      "skill_id": "binder_root_cause",
      "source": {
        "path": "backend/skills/atomic/binder_root_cause.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "bbf84b8491afbaad8a2a80e57d0fba5940008d70944ce362ad6f03dcc476115d"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder_breakdown",
          "android.binder"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "slow_binder_breakdown",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "min_dur_ms",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "binder_root_cause/blame_summary",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/binder_root_cause/blame_summary.sql",
      "sha256": "ed30c5d4ffa69f580e6858370a4d924964b0270dedc9b831013d1afaa59e8b72",
      "signal_patterns": [],
      "skill_id": "binder_root_cause",
      "source": {
        "path": "backend/skills/atomic/binder_root_cause.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "bbf84b8491afbaad8a2a80e57d0fba5940008d70944ce362ad6f03dcc476115d"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder_breakdown",
          "android.binder"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "blame_summary",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "min_dur_ms",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "binder_root_cause"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "binder_storm_detection/binder_density",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/binder_storm_detection/binder_density.sql",
      "sha256": "f0c0f1c5d1eac38f087808dd19f973f507907db881c2857bd0195bc057b3dd67",
      "signal_patterns": [],
      "skill_id": "binder_storm_detection",
      "source": {
        "path": "backend/skills/atomic/binder_storm_detection.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "a412a8c95a1140cfb4eb8306d38fb6506c821a302636b302bb1f55f06821775d"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "binder_density",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts",
          "threshold"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "binder_storm_detection/burst_detection",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/binder_storm_detection/burst_detection.sql",
      "sha256": "0521a8b80481e0a821a810d5bbf7f0c3eb2e0aa07d74afe0f48144f40fb7d0b8",
      "signal_patterns": [],
      "skill_id": "binder_storm_detection",
      "source": {
        "path": "backend/skills/atomic/binder_storm_detection.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "a412a8c95a1140cfb4eb8306d38fb6506c821a302636b302bb1f55f06821775d"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "burst_detection",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts",
          "threshold"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "binder_storm_detection/callback_loops",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/binder_storm_detection/callback_loops.sql",
      "sha256": "7f261e8646bb688867c872ffe395407c036b0105ad6feb2eac49f06f9cccc798",
      "signal_patterns": [],
      "skill_id": "binder_storm_detection",
      "source": {
        "path": "backend/skills/atomic/binder_storm_detection.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "a412a8c95a1140cfb4eb8306d38fb6506c821a302636b302bb1f55f06821775d"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "callback_loops",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "binder_storm_detection/buffer_pressure",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/binder_storm_detection/buffer_pressure.sql",
      "sha256": "54bbdb6ce9d781e9ec4b0373423d24dcb3c3121dacfbf97fdb3ff5be721f1bf9",
      "signal_patterns": [],
      "skill_id": "binder_storm_detection",
      "source": {
        "path": "backend/skills/atomic/binder_storm_detection.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "a412a8c95a1140cfb4eb8306d38fb6506c821a302636b302bb1f55f06821775d"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "buffer_pressure",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "binder_storm_detection"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "blocking_chain_analysis/thread_state_distribution",
      "identity": {
        "aliases": [
          "process_name",
          "package"
        ],
        "minConfidence": 50,
        "policy": "required",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/blocking_chain_analysis/thread_state_distribution.sql",
      "sha256": "454a372c2b3f9732d71e2096b8dc5aae2533205800e3c75f000c1c40d95bc037",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "blocking_chain_analysis",
      "source": {
        "path": "backend/skills/atomic/blocking_chain_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "ec3db5b12031c8cedf7480f0e7496dd03c5a0e7ecad513cc72cd26cf8e68c0a2"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "thread_state",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "thread_state_distribution",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "blocking_chain_analysis/waker_chain",
      "identity": {
        "aliases": [
          "process_name",
          "package"
        ],
        "minConfidence": 50,
        "policy": "required",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/blocking_chain_analysis/waker_chain.sql",
      "sha256": "340d8ed1c36b729a88abde0857b00e0389187cea5ff3aa46e6757e0f4d9532f5",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*",
        "*Decode*",
        "*Dispatcher*",
        "*Executor*",
        "*Network*",
        "*Worker*",
        "*decode*",
        "*netd",
        "*surfaceflinger",
        "/vendor/bin/*",
        "1.raster",
        "1.ui",
        "AsyncTask*",
        "Binder:*",
        "ChromiumNet*",
        "Coil*",
        "CrRendererMain*",
        "Cronet*",
        "DefaultDispatcher*",
        "Dispatchers.Default*",
        "FinalizerDaemon*",
        "Fresco*",
        "Glide*",
        "HeapTaskDaemon*",
        "HwBinder:*",
        "Jit thread pool*",
        "NetworkThread*",
        "OkHttp*",
        "Okio*",
        "Profile Saver*",
        "ReferenceQueueD*",
        "RenderThread*",
        "RxCached*",
        "Signal Catcher*",
        "android.hardware.*",
        "arch_disk_io*",
        "binder:*",
        "glide*",
        "hwbinder:*",
        "pool-*",
        "swapper*",
        "system_server",
        "vendor.*"
      ],
      "skill_id": "blocking_chain_analysis",
      "source": {
        "path": "backend/skills/atomic/blocking_chain_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "ec3db5b12031c8cedf7480f0e7496dd03c5a0e7ecad513cc72cd26cf8e68c0a2"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "thread_state",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "waker_chain",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/thread_role.sql",
            "source_sha256": "8e6239fd0742fc970ad20fcf7b8586fed7f684f6dc227516b5fdfae5f47944fa"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/sleep_wake_source.sql",
            "source_sha256": "6d03353d2ae3fad6663a5cc89c2e8e5c93396a561d94b7024240fcb657f34536"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/sleep_wake_source_labels.sql",
            "source_sha256": "7a69e442e55ca34f719c45c80f7982a46097b63e5164e482fbb191db8e7059d4"
          }
        ],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "blocking_chain_analysis/wakeup_chain_trace",
      "identity": {
        "aliases": [
          "process_name",
          "package"
        ],
        "minConfidence": 50,
        "policy": "required",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/blocking_chain_analysis/wakeup_chain_trace.sql",
      "sha256": "43d7e4de8c877fdc07adaa47fd6c557b448736ef466007e17e5cd0da45248b04",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "blocking_chain_analysis",
      "source": {
        "path": "backend/skills/atomic/blocking_chain_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "ec3db5b12031c8cedf7480f0e7496dd03c5a0e7ecad513cc72cd26cf8e68c0a2"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "thread_state",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "wakeup_chain_trace",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "max_hops",
          "min_wait_ms",
          "process_name",
          "start_ts",
          "top_waits"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "blocking_chain_analysis/blocked_function_summary",
      "identity": {
        "aliases": [
          "process_name",
          "package"
        ],
        "minConfidence": 50,
        "policy": "required",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/blocking_chain_analysis/blocked_function_summary.sql",
      "sha256": "d5d4d77a563be09a5e6ee35827f5f70db1f7fee514b057bcb3632a3dd81da91c",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "blocking_chain_analysis",
      "source": {
        "path": "backend/skills/atomic/blocking_chain_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "ec3db5b12031c8cedf7480f0e7496dd03c5a0e7ecad513cc72cd26cf8e68c0a2"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "thread_state",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "blocked_function_summary",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "blocking_chain_analysis"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "block_io_analysis/data_check",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/block_io_analysis/data_check.sql",
      "sha256": "2ce0d5cfba9ab87e3565867a9637a9b1ff3fd4bbafc99daf1d8d0ba09c56b054",
      "signal_patterns": [],
      "skill_id": "block_io_analysis",
      "source": {
        "path": "backend/skills/composite/block_io_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "6694949cda0a83aa4448782fcdc7b6b7fb8c62134598018d5f702eb571a23985"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.block_io"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "data_check",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "block_io_analysis/io_overview",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/block_io_analysis/io_overview.sql",
      "sha256": "7512eee91a40d7d0dfdf81f596c4fb550c9e2a98b7effed9c55b65ef912f088c",
      "signal_patterns": [],
      "skill_id": "block_io_analysis",
      "source": {
        "path": "backend/skills/composite/block_io_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "6694949cda0a83aa4448782fcdc7b6b7fb8c62134598018d5f702eb571a23985"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.block_io"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "io_overview",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "block_io_analysis/device_io_stats",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/block_io_analysis/device_io_stats.sql",
      "sha256": "7e05ef44fab6848b68a6c1fcb37bf8ee5a71599b98211e34915d54145dcb4e74",
      "signal_patterns": [],
      "skill_id": "block_io_analysis",
      "source": {
        "path": "backend/skills/composite/block_io_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "6694949cda0a83aa4448782fcdc7b6b7fb8c62134598018d5f702eb571a23985"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.block_io"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "device_io_stats",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "device",
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "block_io_analysis/io_queue_depth",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/block_io_analysis/io_queue_depth.sql",
      "sha256": "f06561f917748e530fbad2888100268592cf57630fd224a6d57b63b182f17f21",
      "signal_patterns": [],
      "skill_id": "block_io_analysis",
      "source": {
        "path": "backend/skills/composite/block_io_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "6694949cda0a83aa4448782fcdc7b6b7fb8c62134598018d5f702eb571a23985"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.block_io"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "io_queue_depth",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "device",
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "block_io_analysis/high_queue_periods",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/block_io_analysis/high_queue_periods.sql",
      "sha256": "a299307ac9daf10a7d1f5e9a200e808659cb892635d775368fdfd2a9124286ce",
      "signal_patterns": [],
      "skill_id": "block_io_analysis",
      "source": {
        "path": "backend/skills/composite/block_io_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "6694949cda0a83aa4448782fcdc7b6b7fb8c62134598018d5f702eb571a23985"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.block_io"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "high_queue_periods",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "device",
          "end_ts",
          "min_queue_depth",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "block_io_analysis/long_io_operations",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/block_io_analysis/long_io_operations.sql",
      "sha256": "425719fa30e18a3b24da112a57c7c401d1a267379993d9b0a176696335793521",
      "signal_patterns": [],
      "skill_id": "block_io_analysis",
      "source": {
        "path": "backend/skills/composite/block_io_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "6694949cda0a83aa4448782fcdc7b6b7fb8c62134598018d5f702eb571a23985"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.block_io"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "long_io_operations",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "device",
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "block_io_analysis/io_thread_blocking",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/block_io_analysis/io_thread_blocking.sql",
      "sha256": "d5f49861112cdb4fefaf9b9a8f21f72dbac617508e5fd762febd223b07e4309b",
      "signal_patterns": [],
      "skill_id": "block_io_analysis",
      "source": {
        "path": "backend/skills/composite/block_io_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "6694949cda0a83aa4448782fcdc7b6b7fb8c62134598018d5f702eb571a23985"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.block_io"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "io_thread_blocking",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "block_io_analysis/root_cause_classification",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/block_io_analysis/root_cause_classification.sql",
      "sha256": "373d27e3f0a9f38c78ae9af391bb560b167270ee32a5498addacee2eac182789",
      "signal_patterns": [],
      "skill_id": "block_io_analysis",
      "source": {
        "path": "backend/skills/composite/block_io_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "6694949cda0a83aa4448782fcdc7b6b7fb8c62134598018d5f702eb571a23985"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.block_io"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root_cause_classification",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "block_io_analysis"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "buffer_transaction_lifecycle/apply_transaction_summary",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/buffer_transaction_lifecycle/apply_transaction_summary.sql",
      "sha256": "b1af372dce63a62e84a465840078cb3a3578df16180878d44ce87197003b2b07",
      "signal_patterns": [
        "*BLASTBufferQueue*",
        "*acquireBuffer*",
        "*applyTransaction*",
        "*latchBuffer*",
        "*queueBuffer*",
        "*setTransactionState*",
        "surfaceflinger"
      ],
      "skill_id": "buffer_transaction_lifecycle",
      "source": {
        "path": "backend/skills/atomic/buffer_transaction_lifecycle.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "38cb7cb1b6874a31a2da8e82406e81c04fade5230ec56e948f7bfd2539a6a85b"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "apply_transaction_summary",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "buffer_transaction_lifecycle/queue_to_transaction_delay",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/buffer_transaction_lifecycle/queue_to_transaction_delay.sql",
      "sha256": "1990bef78e38913269aa6a30d77f05c59807b388dba3636f8a3170dee92cab66",
      "signal_patterns": [
        "*applyTransaction*",
        "*queueBuffer*",
        "surfaceflinger"
      ],
      "skill_id": "buffer_transaction_lifecycle",
      "source": {
        "path": "backend/skills/atomic/buffer_transaction_lifecycle.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "38cb7cb1b6874a31a2da8e82406e81c04fade5230ec56e948f7bfd2539a6a85b"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "queue_to_transaction_delay",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "buffer_transaction_lifecycle/per_layer_transactions",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/buffer_transaction_lifecycle/per_layer_transactions.sql",
      "sha256": "2e9d4cb92181f6ff70883e0d2704d6f61a31daaddce6eca003c59c485720e37a",
      "signal_patterns": [],
      "skill_id": "buffer_transaction_lifecycle",
      "source": {
        "path": "backend/skills/atomic/buffer_transaction_lifecycle.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "38cb7cb1b6874a31a2da8e82406e81c04fade5230ec56e948f7bfd2539a6a85b"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "per_layer_transactions",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "buffer_transaction_lifecycle"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "cache_miss_impact/root",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cache_miss_impact/query.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "1975fed5f15d4933991a003b9993f5ace010c37120abd75f3d82ce916233d184",
      "signal_patterns": [],
      "skill_id": "cache_miss_impact",
      "source": {
        "path": "backend/skills/atomic/cache_miss_impact.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "a5e9c2ce0744ad86c74e38152e285cb285995961d91fb7b32c43d5f68844dad6"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "counter",
          "counter_track"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "high_impact_threshold",
          "medium_impact_threshold",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "cache_miss_impact"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "callstack_analysis/check_samples",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/callstack_analysis/check_samples.sql",
      "sha256": "80ae9f26358ef98112f3516191ace7c415da56bce51fd3b03e40d8145b9b183f",
      "signal_patterns": [],
      "skill_id": "callstack_analysis",
      "source": {
        "path": "backend/skills/deep/callstack_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "fc08d54c591a45a1488f7d1064504f08f7d3d2fa95b42eec2a1c6da725ec5f08"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "check_samples",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "verified",
        "execution_verified": true,
        "fixtures": [
          "callstack-sampling"
        ],
        "runtime_compatible": true,
        "semantic_verified": true,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "callstack_analysis/hot_functions",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/callstack_analysis/hot_functions.sql",
      "sha256": "b03cc6508eb244c7487785a22ef4e6011f4037fed5e3346ae482e063fd0921d3",
      "signal_patterns": [],
      "skill_id": "callstack_analysis",
      "source": {
        "path": "backend/skills/deep/callstack_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "fc08d54c591a45a1488f7d1064504f08f7d3d2fa95b42eec2a1c6da725ec5f08"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "hot_functions",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "min_samples"
        ],
        "result_dependencies": [
          "sample_stats"
        ],
        "result_references": [
          "sample_stats"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "callstack_analysis/module_distribution",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/callstack_analysis/module_distribution.sql",
      "sha256": "29bb48a6c78be98a8474ad2b63dcdcdfeb276097311cf54a5a0b2f9cc8d84024",
      "signal_patterns": [
        "%.apk",
        "%.dex",
        "%.so",
        "%kernel%",
        "%vmlinux%"
      ],
      "skill_id": "callstack_analysis",
      "source": {
        "path": "backend/skills/deep/callstack_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "fc08d54c591a45a1488f7d1064504f08f7d3d2fa95b42eec2a1c6da725ec5f08"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "module_distribution",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "callstack_analysis/thread_hotspots",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/callstack_analysis/thread_hotspots.sql",
      "sha256": "d04dbdc0a6eed3930bdb465d09e1a65d391732a7e3e76f0c9ac62a7ea1241e7b",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "callstack_analysis",
      "source": {
        "path": "backend/skills/deep/callstack_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "fc08d54c591a45a1488f7d1064504f08f7d3d2fa95b42eec2a1c6da725ec5f08"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "thread_hotspots",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "callstack_analysis/caller_analysis",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/callstack_analysis/caller_analysis.sql",
      "sha256": "6dd85e36f7a9aa349928cfb49f37b6a68a0a266c7c58bee2cc54631cfd2b8745",
      "signal_patterns": [],
      "skill_id": "callstack_analysis",
      "source": {
        "path": "backend/skills/deep/callstack_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "fc08d54c591a45a1488f7d1064504f08f7d3d2fa95b42eec2a1c6da725ec5f08"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "caller_analysis",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [
          "hot_functions"
        ],
        "result_references": [
          "hot_functions"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "callstack_analysis/analysis_conclusion",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/callstack_analysis/analysis_conclusion.sql",
      "sha256": "c04626b91dc3b64fb531f6cc5fb20467eb77b32549433ac204ef335887520dcd",
      "signal_patterns": [],
      "skill_id": "callstack_analysis",
      "source": {
        "path": "backend/skills/deep/callstack_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "fc08d54c591a45a1488f7d1064504f08f7d3d2fa95b42eec2a1c6da725ec5f08"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "analysis_conclusion",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [
          "hot_functions",
          "module_distribution",
          "sample_stats"
        ],
        "result_references": [
          "hot_functions",
          "module_distribution",
          "sample_stats"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "callstack_analysis"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "camera_trace_evidence/evidence_coverage",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/camera_trace_evidence/evidence_coverage.sql",
      "sha256": "059d846948cc889155dc11e81b65b9b02999938b0f86c3b9ecf9eda8f38e2218",
      "signal_patterns": [
        "mem.ion_change*"
      ],
      "skill_id": "camera_trace_evidence",
      "source": {
        "path": "backend/skills/composite/camera_trace_evidence.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "d2f99680715212f30bafe86e1323d04cb469e5582ac89cad1e8c7b48f92e9c2e"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "slices.with_context",
          "android.binder",
          "android.frames.timeline",
          "android.memory.dmabuf",
          "linux.cpu.frequency",
          "pixel.camera"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "evidence_coverage",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "max_rows",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "camera_trace_evidence/camera_process_candidates",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/camera_trace_evidence/camera_process_candidates.sql",
      "sha256": "0cd0c4e5d7dda4f95048309ed2c2158c0f3e0834caca3238f66fa50291717570",
      "signal_patterns": [],
      "skill_id": "camera_trace_evidence",
      "source": {
        "path": "backend/skills/composite/camera_trace_evidence.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "d2f99680715212f30bafe86e1323d04cb469e5582ac89cad1e8c7b48f92e9c2e"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "slices.with_context",
          "android.binder",
          "android.frames.timeline",
          "android.memory.dmabuf",
          "linux.cpu.frequency",
          "pixel.camera"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "camera_process_candidates",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "max_rows",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "camera_trace_evidence/camera_slice_candidates",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/camera_trace_evidence/camera_slice_candidates.sql",
      "sha256": "4b7ec02383f11598471e9a78f3dcc5d810a4b636c40ed71608e6fa8c0df06454",
      "signal_patterns": [],
      "skill_id": "camera_trace_evidence",
      "source": {
        "path": "backend/skills/composite/camera_trace_evidence.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "d2f99680715212f30bafe86e1323d04cb469e5582ac89cad1e8c7b48f92e9c2e"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "slices.with_context",
          "android.binder",
          "android.frames.timeline",
          "android.memory.dmabuf",
          "linux.cpu.frequency",
          "pixel.camera"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "camera_slice_candidates",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "max_rows",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "camera_trace_evidence/camera_binder_summary",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/camera_trace_evidence/camera_binder_summary.sql",
      "sha256": "355dff285a76ae17951552f61e3fd8e26833b69e12fc9f977f6317fb11c03cba",
      "signal_patterns": [],
      "skill_id": "camera_trace_evidence",
      "source": {
        "path": "backend/skills/composite/camera_trace_evidence.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "d2f99680715212f30bafe86e1323d04cb469e5582ac89cad1e8c7b48f92e9c2e"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "slices.with_context",
          "android.binder",
          "android.frames.timeline",
          "android.memory.dmabuf",
          "linux.cpu.frequency",
          "pixel.camera"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "camera_binder_summary",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "max_rows",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "camera_trace_evidence/camera_dmabuf_summary",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/camera_trace_evidence/camera_dmabuf_summary.sql",
      "sha256": "0ee3ec2ec3704b7aee8dac738294d1be88c4d99694551805ef13fc44e647dd3d",
      "signal_patterns": [
        "mem.ion_change*"
      ],
      "skill_id": "camera_trace_evidence",
      "source": {
        "path": "backend/skills/composite/camera_trace_evidence.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "d2f99680715212f30bafe86e1323d04cb469e5582ac89cad1e8c7b48f92e9c2e"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "slices.with_context",
          "android.binder",
          "android.frames.timeline",
          "android.memory.dmabuf",
          "linux.cpu.frequency",
          "pixel.camera"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "camera_dmabuf_summary",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "max_rows",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "camera_trace_evidence/pixel_camera_stage_summary",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/camera_trace_evidence/pixel_camera_stage_summary.sql",
      "sha256": "9639289df664db5f65313c1eb36b0103de3916c79069f17e14e63cfaf121de78",
      "signal_patterns": [],
      "skill_id": "camera_trace_evidence",
      "source": {
        "path": "backend/skills/composite/camera_trace_evidence.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "d2f99680715212f30bafe86e1323d04cb469e5582ac89cad1e8c7b48f92e9c2e"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "slices.with_context",
          "android.binder",
          "android.frames.timeline",
          "android.memory.dmabuf",
          "linux.cpu.frequency",
          "pixel.camera"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "pixel_camera_stage_summary",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "max_rows",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "camera_trace_evidence"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "choreographer_module/doframe_overview",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/choreographer_module/doframe_overview.sql",
      "sha256": "f5e15bc8e6d67aebb761d207f36bb81d12b7d2254a641d361b05d60d90a63047",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*Choreographer#doFrame*",
        "*Choreographer*",
        "*doFrame*"
      ],
      "skill_id": "choreographer_module",
      "source": {
        "path": "backend/skills/modules/framework/choreographer_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "50ab26350db4695faed48050143b69a472c511af5a36fcc610e6e6b192860e66"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "doframe_overview",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "package",
          "vsync_period_ns"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "choreographer_module/doframe_timeline",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/choreographer_module/doframe_timeline.sql",
      "sha256": "617d58fc005fbae071a5b68cb392858c7dfdf2cfae4b1f12e63597d761c2153f",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*Choreographer#doFrame*",
        "*doFrame*"
      ],
      "skill_id": "choreographer_module",
      "source": {
        "path": "backend/skills/modules/framework/choreographer_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "50ab26350db4695faed48050143b69a472c511af5a36fcc610e6e6b192860e66"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "doframe_timeline",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "package",
          "vsync_period_ns"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "choreographer_module/callback_breakdown",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/choreographer_module/callback_breakdown.sql",
      "sha256": "d0c1c10f86c4eae25e4e14b67a08c2a1213ca20f399a47a7c1b5a1a20897b8c4",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*Animation*",
        "*Input*",
        "*Traversal*",
        "*animation*",
        "*draw*",
        "*input*",
        "*layout*",
        "*measure*",
        "*traversal*"
      ],
      "skill_id": "choreographer_module",
      "source": {
        "path": "backend/skills/modules/framework/choreographer_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "50ab26350db4695faed48050143b69a472c511af5a36fcc610e6e6b192860e66"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "callback_breakdown",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "choreographer_module/long_frames",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/choreographer_module/long_frames.sql",
      "sha256": "0eaa356e477c04c9fa17da75ae05617ecf01416a906074d2f8423e452e37ed3d",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*Choreographer#doFrame*",
        "*doFrame*"
      ],
      "skill_id": "choreographer_module",
      "source": {
        "path": "backend/skills/modules/framework/choreographer_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "50ab26350db4695faed48050143b69a472c511af5a36fcc610e6e6b192860e66"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "long_frames",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "package",
          "vsync_period_ns"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "choreographer_module/view_traversal",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/choreographer_module/view_traversal.sql",
      "sha256": "563d67cbd5d4eaf9df35bd0d3b1393d40d31009c5d382bf129bcf6295a03917b",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*Draw*",
        "*Layout*",
        "*Measure*",
        "*draw*",
        "*layout*",
        "*measure*"
      ],
      "skill_id": "choreographer_module",
      "source": {
        "path": "backend/skills/modules/framework/choreographer_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "50ab26350db4695faed48050143b69a472c511af5a36fcc610e6e6b192860e66"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "view_traversal",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "choreographer_module/frame_pipeline",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/choreographer_module/frame_pipeline.sql",
      "sha256": "8875085c8c73b2da806b7ac69f7430855d005a2e72e1eca36318dbd8ec61b415",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*DrawFrame*",
        "*acquireBuffer*",
        "*dequeueBuffer*",
        "*eglSwapBuffers*",
        "*queueBuffer*",
        "*syncFrameState*"
      ],
      "skill_id": "choreographer_module",
      "source": {
        "path": "backend/skills/modules/framework/choreographer_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "50ab26350db4695faed48050143b69a472c511af5a36fcc610e6e6b192860e66"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "frame_pipeline",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "choreographer_module"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "chrome_scroll_jank_frame_timeline/chrome_trace_availability",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/chrome_scroll_jank_frame_timeline/chrome_trace_availability.sql",
      "sha256": "1ef31f6e2f74cacac6792af841a386a7f136ed0fb95742b870d421a685ae1208",
      "signal_patterns": [
        "Extend_VSync"
      ],
      "skill_id": "chrome_scroll_jank_frame_timeline",
      "source": {
        "path": "backend/skills/atomic/chrome_scroll_jank_frame_timeline.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "2aa88e4f3cc40101c7a97eefeb3cfa517026c5c827e22d0cd8894af2a57da2a4"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "chrome.chrome_scrolls",
          "chrome.chrome_scrolls_v4",
          "chrome.scroll_jank.scroll_jank_intervals",
          "chrome.scroll_jank_v4",
          "chrome.scroll_jank_tagging"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "chrome_trace_availability",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "chrome_scroll_jank_frame_timeline/chrome_scroll_v3_summary",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/chrome_scroll_jank_frame_timeline/chrome_scroll_v3_summary.sql",
      "sha256": "12eb9bd3c8823c3e862acf1997f97e0f19315d8ce65654e66103bb1ed268950a",
      "signal_patterns": [],
      "skill_id": "chrome_scroll_jank_frame_timeline",
      "source": {
        "path": "backend/skills/atomic/chrome_scroll_jank_frame_timeline.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "2aa88e4f3cc40101c7a97eefeb3cfa517026c5c827e22d0cd8894af2a57da2a4"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "chrome.chrome_scrolls",
          "chrome.chrome_scrolls_v4",
          "chrome.scroll_jank.scroll_jank_intervals",
          "chrome.scroll_jank_v4",
          "chrome.scroll_jank_tagging"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "chrome_scroll_v3_summary",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "min_janky_frames",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "chrome_scroll_jank_frame_timeline/chrome_scroll_v4_janky_frames",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/chrome_scroll_jank_frame_timeline/chrome_scroll_v4_janky_frames.sql",
      "sha256": "27a08680a5f5edb51c2093d8ed2ada771fab2f7d4da25ebac1e930f0397e2c3f",
      "signal_patterns": [],
      "skill_id": "chrome_scroll_jank_frame_timeline",
      "source": {
        "path": "backend/skills/atomic/chrome_scroll_jank_frame_timeline.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "2aa88e4f3cc40101c7a97eefeb3cfa517026c5c827e22d0cd8894af2a57da2a4"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "chrome.chrome_scrolls",
          "chrome.chrome_scrolls_v4",
          "chrome.scroll_jank.scroll_jank_intervals",
          "chrome.scroll_jank_v4",
          "chrome.scroll_jank_tagging"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "chrome_scroll_v4_janky_frames",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "chrome_scroll_jank_frame_timeline/chrome_preferred_frame_timeline",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/chrome_scroll_jank_frame_timeline/chrome_preferred_frame_timeline.sql",
      "sha256": "9eafc92f2a7cbfc53b17bea6625aab1b285d1db81c3d93372b0ae890b2499ed1",
      "signal_patterns": [
        "Extend_VSync"
      ],
      "skill_id": "chrome_scroll_jank_frame_timeline",
      "source": {
        "path": "backend/skills/atomic/chrome_scroll_jank_frame_timeline.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "2aa88e4f3cc40101c7a97eefeb3cfa517026c5c827e22d0cd8894af2a57da2a4"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "chrome.chrome_scrolls",
          "chrome.chrome_scrolls_v4",
          "chrome.scroll_jank.scroll_jank_intervals",
          "chrome.scroll_jank_v4",
          "chrome.scroll_jank_tagging"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "chrome_preferred_frame_timeline",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "chrome_scroll_jank_frame_timeline"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "click_response_analysis/check_input_data",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/click_response_analysis/check_input_data.sql",
      "process_scope": {
        "binding": "native_upid",
        "role": "target"
      },
      "sha256": "6eda361d9f85767d927236309a550ea953ad733c4193f36a25815eecaf63206a",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "click_response_analysis",
      "source": {
        "path": "backend/skills/composite/click_response_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "03b5d4aa8b1a9a35544b024cba0e9f19905aed03fa034951999ef8dd10a8d371"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.input",
          "android.binder",
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "android_input_events"
        ],
        "setup_queries": [
          "scrolling_analysis/input_data_fallback_view"
        ]
      },
      "step_id": "check_input_data",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/android_input_events_normalized.sql",
            "source_sha256": "f43bd5a184bdb678fda9a90f950048cfd659b52f11fe57dab107a7d13abd60a5"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/android_input_delivery_roles.sql",
            "source_sha256": "9e43fdd5a50a207f0da9be059a3163b5b691d3efd8077e524066a1379e3013e3"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/android_input_scoped_deliveries.sql",
            "source_sha256": "d714ec458a5ed924aa621caa3404b7580e066e6180e755a34236488b01944d72"
          },
          {
            "order": 3,
            "source_path": "backend/skills/fragments/android_input_target_deliveries.sql",
            "source_sha256": "e5b536f5bdf8253624544c5b890b48678a8de251efdea8b00288989a9b8d797f"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "click_response_analysis/get_process",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/click_response_analysis/get_process.sql",
      "process_scope": {
        "binding": "native_upid",
        "role": "target"
      },
      "sha256": "0b4accd4f894b74b8124cdcf5b29320db722c456d373879bbc51154301e4471c",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "click_response_analysis",
      "source": {
        "path": "backend/skills/composite/click_response_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "03b5d4aa8b1a9a35544b024cba0e9f19905aed03fa034951999ef8dd10a8d371"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.input",
          "android.binder",
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "android_input_events"
        ],
        "setup_queries": [
          "scrolling_analysis/input_data_fallback_view"
        ]
      },
      "step_id": "get_process",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/android_input_events_normalized.sql",
            "source_sha256": "f43bd5a184bdb678fda9a90f950048cfd659b52f11fe57dab107a7d13abd60a5"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/android_input_delivery_roles.sql",
            "source_sha256": "9e43fdd5a50a207f0da9be059a3163b5b691d3efd8077e524066a1379e3013e3"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/android_input_scoped_deliveries.sql",
            "source_sha256": "d714ec458a5ed924aa621caa3404b7580e066e6180e755a34236488b01944d72"
          },
          {
            "order": 3,
            "source_path": "backend/skills/fragments/android_input_target_deliveries.sql",
            "source_sha256": "e5b536f5bdf8253624544c5b890b48678a8de251efdea8b00288989a9b8d797f"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "click_response_analysis/input_latency_overview",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/click_response_analysis/input_latency_overview.sql",
      "process_scope": {
        "binding": "native_upid",
        "role": "target"
      },
      "sha256": "8e61d166493857b1d4a3fa45b0d1b869f26ecd01df6772cf4c43d433800177d2",
      "signal_patterns": [
        "${target_process.data[0].process_name}"
      ],
      "skill_id": "click_response_analysis",
      "source": {
        "path": "backend/skills/composite/click_response_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "03b5d4aa8b1a9a35544b024cba0e9f19905aed03fa034951999ef8dd10a8d371"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.input",
          "android.binder",
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "android_input_events"
        ],
        "setup_queries": [
          "scrolling_analysis/input_data_fallback_view"
        ]
      },
      "step_id": "input_latency_overview",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/android_input_events_normalized.sql",
            "source_sha256": "f43bd5a184bdb678fda9a90f950048cfd659b52f11fe57dab107a7d13abd60a5"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/android_input_delivery_roles.sql",
            "source_sha256": "9e43fdd5a50a207f0da9be059a3163b5b691d3efd8077e524066a1379e3013e3"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/android_input_scoped_deliveries.sql",
            "source_sha256": "d714ec458a5ed924aa621caa3404b7580e066e6180e755a34236488b01944d72"
          },
          {
            "order": 3,
            "source_path": "backend/skills/fragments/android_input_target_deliveries.sql",
            "source_sha256": "e5b536f5bdf8253624544c5b890b48678a8de251efdea8b00288989a9b8d797f"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "critical_event_threshold_ms",
          "end_ts",
          "slow_event_threshold_ms",
          "start_ts"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "click_response_analysis/latency_by_event_type",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/click_response_analysis/latency_by_event_type.sql",
      "process_scope": {
        "binding": "native_upid",
        "role": "target"
      },
      "sha256": "47e9f44932937e06697f3610dae266a4a36acacf9dd40ec1d9f03b8a2d22001b",
      "signal_patterns": [
        "${target_process.data[0].process_name}"
      ],
      "skill_id": "click_response_analysis",
      "source": {
        "path": "backend/skills/composite/click_response_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "03b5d4aa8b1a9a35544b024cba0e9f19905aed03fa034951999ef8dd10a8d371"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.input",
          "android.binder",
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "android_input_events"
        ],
        "setup_queries": [
          "scrolling_analysis/input_data_fallback_view"
        ]
      },
      "step_id": "latency_by_event_type",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/android_input_events_normalized.sql",
            "source_sha256": "f43bd5a184bdb678fda9a90f950048cfd659b52f11fe57dab107a7d13abd60a5"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/android_input_delivery_roles.sql",
            "source_sha256": "9e43fdd5a50a207f0da9be059a3163b5b691d3efd8077e524066a1379e3013e3"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/android_input_scoped_deliveries.sql",
            "source_sha256": "d714ec458a5ed924aa621caa3404b7580e066e6180e755a34236488b01944d72"
          },
          {
            "order": 3,
            "source_path": "backend/skills/fragments/android_input_target_deliveries.sql",
            "source_sha256": "e5b536f5bdf8253624544c5b890b48678a8de251efdea8b00288989a9b8d797f"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "slow_event_threshold_ms",
          "start_ts"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "click_response_analysis/latency_by_window",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/click_response_analysis/latency_by_window.sql",
      "process_scope": {
        "binding": "native_upid",
        "role": "target"
      },
      "sha256": "7d051f7610e4d744462af1368bb513da4d602073106944e5c39be10061306bcb",
      "signal_patterns": [
        "${target_process.data[0].process_name}"
      ],
      "skill_id": "click_response_analysis",
      "source": {
        "path": "backend/skills/composite/click_response_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "03b5d4aa8b1a9a35544b024cba0e9f19905aed03fa034951999ef8dd10a8d371"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.input",
          "android.binder",
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "android_input_events"
        ],
        "setup_queries": [
          "scrolling_analysis/input_data_fallback_view"
        ]
      },
      "step_id": "latency_by_window",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/android_input_events_normalized.sql",
            "source_sha256": "f43bd5a184bdb678fda9a90f950048cfd659b52f11fe57dab107a7d13abd60a5"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/android_input_delivery_roles.sql",
            "source_sha256": "9e43fdd5a50a207f0da9be059a3163b5b691d3efd8077e524066a1379e3013e3"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/android_input_scoped_deliveries.sql",
            "source_sha256": "d714ec458a5ed924aa621caa3404b7580e066e6180e755a34236488b01944d72"
          },
          {
            "order": 3,
            "source_path": "backend/skills/fragments/android_input_target_deliveries.sql",
            "source_sha256": "e5b536f5bdf8253624544c5b890b48678a8de251efdea8b00288989a9b8d797f"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "slow_event_threshold_ms",
          "start_ts"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "click_response_analysis/slow_input_events",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/click_response_analysis/slow_input_events.sql",
      "process_scope": {
        "binding": "native_upid",
        "role": "target"
      },
      "sha256": "9f71f36f6bec9cd3c166b1afea36f57fdda9febdc176da3575adbb6ca5ad5bd8",
      "signal_patterns": [
        "${target_process.data[0].process_name}"
      ],
      "skill_id": "click_response_analysis",
      "source": {
        "path": "backend/skills/composite/click_response_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "03b5d4aa8b1a9a35544b024cba0e9f19905aed03fa034951999ef8dd10a8d371"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.input",
          "android.binder",
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "android_input_events"
        ],
        "setup_queries": [
          "scrolling_analysis/input_data_fallback_view"
        ]
      },
      "step_id": "slow_input_events",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/android_input_events_normalized.sql",
            "source_sha256": "f43bd5a184bdb678fda9a90f950048cfd659b52f11fe57dab107a7d13abd60a5"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/android_input_delivery_roles.sql",
            "source_sha256": "9e43fdd5a50a207f0da9be059a3163b5b691d3efd8077e524066a1379e3013e3"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/android_input_scoped_deliveries.sql",
            "source_sha256": "d714ec458a5ed924aa621caa3404b7580e066e6180e755a34236488b01944d72"
          },
          {
            "order": 3,
            "source_path": "backend/skills/fragments/android_input_target_deliveries.sql",
            "source_sha256": "e5b536f5bdf8253624544c5b890b48678a8de251efdea8b00288989a9b8d797f"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "critical_event_threshold_ms",
          "end_ts",
          "slow_event_threshold_ms",
          "start_ts"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "click_response_analysis/input_thread_state",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/click_response_analysis/input_thread_state.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "1cf558ff690623787be77b85f09b795d33e4c4a221cd599a221698a9831ddb20",
      "signal_patterns": [
        "${target_process.data[0].process_name}"
      ],
      "skill_id": "click_response_analysis",
      "source": {
        "path": "backend/skills/composite/click_response_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "03b5d4aa8b1a9a35544b024cba0e9f19905aed03fa034951999ef8dd10a8d371"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.input",
          "android.binder",
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "android_input_events"
        ],
        "setup_queries": [
          "scrolling_analysis/input_data_fallback_view"
        ]
      },
      "step_id": "input_thread_state",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/android_input_events_normalized.sql",
            "source_sha256": "f43bd5a184bdb678fda9a90f950048cfd659b52f11fe57dab107a7d13abd60a5"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/android_input_delivery_roles.sql",
            "source_sha256": "9e43fdd5a50a207f0da9be059a3163b5b691d3efd8077e524066a1379e3013e3"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/android_input_scoped_deliveries.sql",
            "source_sha256": "d714ec458a5ed924aa621caa3404b7580e066e6180e755a34236488b01944d72"
          },
          {
            "order": 3,
            "source_path": "backend/skills/fragments/android_input_target_deliveries.sql",
            "source_sha256": "e5b536f5bdf8253624544c5b890b48678a8de251efdea8b00288989a9b8d797f"
          },
          {
            "order": 4,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          },
          {
            "order": 5,
            "source_path": "backend/skills/fragments/system_thread_state_spans.sql",
            "source_sha256": "40a17843f23e9cd7a249735450ff58accb11c2ecb13ac8c22f3f9ff31bcadaa1"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts",
          "thread_state_min_dur_ms"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "click_response_analysis/input_binder_calls",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/click_response_analysis/input_binder_calls.sql",
      "process_scope": {
        "binding": "native_upid",
        "context_fields": {
          "peer_context": [
            "server_process",
            "aidl_name"
          ]
        },
        "role": "target"
      },
      "sha256": "4dd2495f52bdb6199180989e416b19f5334541262c74b33fcf73a4fe2a6fcf70",
      "signal_patterns": [
        "${target_process.data[0].process_name}"
      ],
      "skill_id": "click_response_analysis",
      "source": {
        "path": "backend/skills/composite/click_response_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "03b5d4aa8b1a9a35544b024cba0e9f19905aed03fa034951999ef8dd10a8d371"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.input",
          "android.binder",
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "android_input_events"
        ],
        "setup_queries": [
          "scrolling_analysis/input_data_fallback_view"
        ]
      },
      "step_id": "input_binder_calls",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/android_input_events_normalized.sql",
            "source_sha256": "f43bd5a184bdb678fda9a90f950048cfd659b52f11fe57dab107a7d13abd60a5"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/android_input_delivery_roles.sql",
            "source_sha256": "9e43fdd5a50a207f0da9be059a3163b5b691d3efd8077e524066a1379e3013e3"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/android_input_scoped_deliveries.sql",
            "source_sha256": "d714ec458a5ed924aa621caa3404b7580e066e6180e755a34236488b01944d72"
          },
          {
            "order": 3,
            "source_path": "backend/skills/fragments/android_input_target_deliveries.sql",
            "source_sha256": "e5b536f5bdf8253624544c5b890b48678a8de251efdea8b00288989a9b8d797f"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts",
          "thread_state_min_dur_ms"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "click_response_analysis/input_to_frame",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/click_response_analysis/input_to_frame.sql",
      "process_scope": {
        "binding": "native_upid",
        "role": "target"
      },
      "sha256": "e09eae02789d215391127aef8ff4a1fd1c80f563482bb1823333a6a51d8b8abe",
      "signal_patterns": [
        "${target_process.data[0].process_name}"
      ],
      "skill_id": "click_response_analysis",
      "source": {
        "path": "backend/skills/composite/click_response_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "03b5d4aa8b1a9a35544b024cba0e9f19905aed03fa034951999ef8dd10a8d371"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.input",
          "android.binder",
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "android_input_events"
        ],
        "setup_queries": [
          "scrolling_analysis/input_data_fallback_view"
        ]
      },
      "step_id": "input_to_frame",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/android_input_events_normalized.sql",
            "source_sha256": "f43bd5a184bdb678fda9a90f950048cfd659b52f11fe57dab107a7d13abd60a5"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/android_input_delivery_roles.sql",
            "source_sha256": "9e43fdd5a50a207f0da9be059a3163b5b691d3efd8077e524066a1379e3013e3"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/android_input_scoped_deliveries.sql",
            "source_sha256": "d714ec458a5ed924aa621caa3404b7580e066e6180e755a34236488b01944d72"
          },
          {
            "order": 3,
            "source_path": "backend/skills/fragments/android_input_target_deliveries.sql",
            "source_sha256": "e5b536f5bdf8253624544c5b890b48678a8de251efdea8b00288989a9b8d797f"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "critical_event_threshold_ms",
          "end_ts",
          "slow_event_threshold_ms",
          "start_ts",
          "thread_state_min_dur_ms"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "click_response_analysis/latency_distribution",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/click_response_analysis/latency_distribution.sql",
      "process_scope": {
        "binding": "native_upid",
        "role": "target"
      },
      "sha256": "df7758ba713541da61de3a4204d12f75088f5a6446d9868e9fb078b6755d1d8f",
      "signal_patterns": [
        "${target_process.data[0].process_name}"
      ],
      "skill_id": "click_response_analysis",
      "source": {
        "path": "backend/skills/composite/click_response_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "03b5d4aa8b1a9a35544b024cba0e9f19905aed03fa034951999ef8dd10a8d371"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.input",
          "android.binder",
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "android_input_events"
        ],
        "setup_queries": [
          "scrolling_analysis/input_data_fallback_view"
        ]
      },
      "step_id": "latency_distribution",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/android_input_events_normalized.sql",
            "source_sha256": "f43bd5a184bdb678fda9a90f950048cfd659b52f11fe57dab107a7d13abd60a5"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/android_input_delivery_roles.sql",
            "source_sha256": "9e43fdd5a50a207f0da9be059a3163b5b691d3efd8077e524066a1379e3013e3"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/android_input_scoped_deliveries.sql",
            "source_sha256": "d714ec458a5ed924aa621caa3404b7580e066e6180e755a34236488b01944d72"
          },
          {
            "order": 3,
            "source_path": "backend/skills/fragments/android_input_target_deliveries.sql",
            "source_sha256": "e5b536f5bdf8253624544c5b890b48678a8de251efdea8b00288989a9b8d797f"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "click_response_analysis"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "click_response_detail/system_context_window",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/click_response_detail/system_context_window.sql",
      "process_scope": {
        "role": "identity_metadata"
      },
      "sha256": "447b9a79ff766014fd68a94b1b5a7b4933d53c9c2360925ac0494225cdafc045",
      "signal_patterns": [],
      "skill_id": "click_response_detail",
      "source": {
        "path": "backend/skills/composite/click_response_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "9e44f27b6343d60763ebf83af07b3dd5c2d9c22a357c8f8527c54a3f67b5e497"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.input",
          "android.binder",
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [
          "thread",
          "process",
          "thread_state",
          "sched_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "system_context_window",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "event_end_ts",
          "event_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "click_response_detail/event_info",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/click_response_detail/event_info.sql",
      "process_scope": {
        "role": "identity_metadata"
      },
      "sha256": "2fc739e5c8143ea252eeb999b59e6a4c0158c70d610ac07a9eea58b95725e090",
      "signal_patterns": [],
      "skill_id": "click_response_detail",
      "source": {
        "path": "backend/skills/composite/click_response_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "9e44f27b6343d60763ebf83af07b3dd5c2d9c22a357c8f8527c54a3f67b5e497"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.input",
          "android.binder",
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [
          "thread",
          "process",
          "thread_state",
          "sched_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "event_info",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "dispatch_ms",
          "event_action",
          "event_end_ts",
          "event_ts",
          "event_type",
          "handling_ms",
          "perfetto_end",
          "perfetto_start",
          "process_name",
          "total_ms"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "click_response_detail/input_dispatch_breakdown",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/click_response_detail/input_dispatch_breakdown.sql",
      "process_scope": {
        "role": "peer_context"
      },
      "sha256": "ebf8263d5d2e34f2a6ac95674546ed29f664e16684d388c17cc638cfcb81d929",
      "signal_patterns": [
        "*InputDispatcher*",
        "*InputReader*",
        "*dispatchMotion*",
        "/system/bin/%",
        "system_server"
      ],
      "skill_id": "click_response_detail",
      "source": {
        "path": "backend/skills/composite/click_response_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "9e44f27b6343d60763ebf83af07b3dd5c2d9c22a357c8f8527c54a3f67b5e497"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.input",
          "android.binder",
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [
          "thread",
          "process",
          "thread_state",
          "sched_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "input_dispatch_breakdown",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "event_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "click_response_detail/input_app_receive",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/click_response_detail/input_app_receive.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "493b57a62bfaa51824a34f4952e09e91ec48f75bdb91fdc0d1d6cb4993d73490",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*",
        "*InputEvent*",
        "*deliverInput*",
        "aq:pending:deliver*"
      ],
      "skill_id": "click_response_detail",
      "source": {
        "path": "backend/skills/composite/click_response_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "9e44f27b6343d60763ebf83af07b3dd5c2d9c22a357c8f8527c54a3f67b5e497"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.input",
          "android.binder",
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [
          "thread",
          "process",
          "thread_state",
          "sched_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "input_app_receive",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          }
        ],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "event_end_ts",
          "event_ts",
          "process_name"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "click_response_detail/input_pipeline_lifecycle",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/click_response_detail/input_pipeline_lifecycle.sql",
      "process_scope": {
        "binding": "native_upid",
        "role": "target"
      },
      "sha256": "62371796c05103b0add40f23287cf87d2f14486d979d6040366e91c7a5bc492c",
      "signal_patterns": [
        "${process_name}",
        "UnwantedInteractionBlocker::notifyMotion*"
      ],
      "skill_id": "click_response_detail",
      "source": {
        "path": "backend/skills/composite/click_response_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "9e44f27b6343d60763ebf83af07b3dd5c2d9c22a357c8f8527c54a3f67b5e497"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.input",
          "android.binder",
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [
          "thread",
          "process",
          "thread_state",
          "sched_slice"
        ],
        "requires": [
          "android_input_events"
        ],
        "setup_queries": [
          "scrolling_analysis/input_data_fallback_view"
        ]
      },
      "step_id": "input_pipeline_lifecycle",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/android_input_events_normalized.sql",
            "source_sha256": "f43bd5a184bdb678fda9a90f950048cfd659b52f11fe57dab107a7d13abd60a5"
          }
        ],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "event_end_ts",
          "event_ts",
          "process_name"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "click_response_detail/cpu_core_analysis",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/click_response_detail/cpu_core_analysis.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "9241a1bde42c772c4d820644d8c470a5b83e814bc9dce1ef18ff80d685a6e402",
      "signal_patterns": [
        "${process_name}:*"
      ],
      "skill_id": "click_response_detail",
      "source": {
        "path": "backend/skills/composite/click_response_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "9e44f27b6343d60763ebf83af07b3dd5c2d9c22a357c8f8527c54a3f67b5e497"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.input",
          "android.binder",
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [
          "thread",
          "process",
          "thread_state",
          "sched_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "cpu_core_analysis",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/system_sched_spans.sql",
            "source_sha256": "ebcdcc6f476c4109051e817bcd107b1e45351faea14ff238ba76fb3f53b0b032"
          }
        ],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "event_end_ts",
          "event_ts",
          "process_name"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "click_response_detail/quadrant_analysis",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/click_response_detail/quadrant_analysis.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "d576f34c65945e5018099297062fbd6067e4fcb34470173f7b9ff2c7ce71d216",
      "signal_patterns": [
        "${process_name}:*"
      ],
      "skill_id": "click_response_detail",
      "source": {
        "path": "backend/skills/composite/click_response_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "9e44f27b6343d60763ebf83af07b3dd5c2d9c22a357c8f8527c54a3f67b5e497"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.input",
          "android.binder",
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [
          "thread",
          "process",
          "thread_state",
          "sched_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "quadrant_analysis",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/system_thread_state_spans.sql",
            "source_sha256": "40a17843f23e9cd7a249735450ff58accb11c2ecb13ac8c22f3f9ff31bcadaa1"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/system_sched_spans.sql",
            "source_sha256": "ebcdcc6f476c4109051e817bcd107b1e45351faea14ff238ba76fb3f53b0b032"
          }
        ],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "event_end_ts",
          "event_ts",
          "process_name"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "click_response_detail"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "code_pinpoint/hot_slices",
      "identity": {
        "aliases": [
          "package",
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/code_pinpoint/hot_slices.sql",
      "sha256": "43ee1f9145d3f72980a0e63614acc420bef5ae06279816b3afa1a30c64ba9a06",
      "signal_patterns": [],
      "skill_id": "code_pinpoint",
      "source": {
        "path": "backend/skills/composite/code_pinpoint.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "c2560c8a63a870cc090ef0176632c2c572fd52bb4301adaa16342cbb651204ce"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "slices.with_context",
          "android.process_metadata"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "hot_slices",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "code_pinpoint/native_symbols",
      "identity": {
        "aliases": [
          "package",
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/code_pinpoint/native_symbols.sql",
      "sha256": "f5fa3de4445ed6f1496b508a6b47c036355047505f1bf02b40146d6521d30f34",
      "signal_patterns": [],
      "skill_id": "code_pinpoint",
      "source": {
        "path": "backend/skills/composite/code_pinpoint.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "c2560c8a63a870cc090ef0176632c2c572fd52bb4301adaa16342cbb651204ce"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "slices.with_context",
          "android.process_metadata"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "native_symbols",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "code_pinpoint"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "compose_recomposition_hotspot/frame_timeline_check",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/compose_recomposition_hotspot/frame_timeline_check.sql",
      "sha256": "0bc459f29d22c49684370099bce84719d74c386b1d49ed8f4bebdd40fd0ba5da",
      "signal_patterns": [
        "actual_frame_timeline_slice"
      ],
      "skill_id": "compose_recomposition_hotspot",
      "source": {
        "path": "backend/skills/atomic/compose_recomposition_hotspot.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "ba394bc6522c94269f377cc156491c1e086d8b56f93d0b139390c08f76100b3b"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.timeline",
          "slices.with_context"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "thread_track",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "frame_timeline_check",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "compose_recomposition_hotspot/recomposition_overview",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/compose_recomposition_hotspot/recomposition_overview.sql",
      "sha256": "a599da6f06e42ce170fddf6b0b3635cd586361bb9f62f3b21b66128820c8aeda",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*CompositionLocal*",
        "Compose:*",
        "Recompos*"
      ],
      "skill_id": "compose_recomposition_hotspot",
      "source": {
        "path": "backend/skills/atomic/compose_recomposition_hotspot.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "ba394bc6522c94269f377cc156491c1e086d8b56f93d0b139390c08f76100b3b"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.timeline",
          "slices.with_context"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "thread_track",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "recomposition_overview",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "compose_recomposition_hotspot/slow_recompositions",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/compose_recomposition_hotspot/slow_recompositions.sql",
      "sha256": "83e91e69d61b4bee52a0fbbbc7160954846aa454d9bf990e522f33623d5b0a01",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*CompositionLocal*",
        "Compose:*",
        "Recompos*"
      ],
      "skill_id": "compose_recomposition_hotspot",
      "source": {
        "path": "backend/skills/atomic/compose_recomposition_hotspot.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "ba394bc6522c94269f377cc156491c1e086d8b56f93d0b139390c08f76100b3b"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.timeline",
          "slices.with_context"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "thread_track",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "slow_recompositions",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "compose_recomposition_hotspot/composition_frequency",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/compose_recomposition_hotspot/composition_frequency.sql",
      "sha256": "f8bb1b2c3538df10d06796deeed0b719a3225c98c47321774feb4ed3572b08f9",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*CompositionLocal*",
        "Compose:*",
        "Recompos*"
      ],
      "skill_id": "compose_recomposition_hotspot",
      "source": {
        "path": "backend/skills/atomic/compose_recomposition_hotspot.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "ba394bc6522c94269f377cc156491c1e086d8b56f93d0b139390c08f76100b3b"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.timeline",
          "slices.with_context"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "thread_track",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "composition_frequency",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "compose_recomposition_hotspot/recomposition_frame_overlap",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/compose_recomposition_hotspot/recomposition_frame_overlap.sql",
      "sha256": "1bcaf29fd5da2aad2aad6e6534938e8d790b854c82350bd9b383af9d474de23a",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*CompositionLocal*",
        "Compose:*",
        "Recompos*"
      ],
      "skill_id": "compose_recomposition_hotspot",
      "source": {
        "path": "backend/skills/atomic/compose_recomposition_hotspot.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "ba394bc6522c94269f377cc156491c1e086d8b56f93d0b139390c08f76100b3b"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.timeline",
          "slices.with_context"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "thread_track",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "recomposition_frame_overlap",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "compose_recomposition_hotspot"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "frame_timeline"
        ]
      },
      "id": "consumer_jank_detection/vsync_config",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/consumer_jank_detection/vsync_config.sql",
      "sha256": "d91843f1e6d7dc6ea61933cc8c316a98a484e8b99385ebd7859e26b8db0040b6",
      "signal_patterns": [
        "VSYNC-sf"
      ],
      "skill_id": "consumer_jank_detection",
      "source": {
        "path": "backend/skills/atomic/consumer_jank_detection.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1cabbcaffac2059d6095ba3df586dcd0990a0a9879057a8e8d44f7c3bf3756fc"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.timeline",
          "android.frames.jank_type"
        ],
        "drops": [],
        "required_tables": [
          "actual_frame_timeline_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "vsync_config",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "frame_timeline"
        ]
      },
      "id": "consumer_jank_detection/presentation_cadence_audit",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/consumer_jank_detection/presentation_cadence_audit.sql",
      "sha256": "7401dda265d88d9c4723213c79c90c517b5df00368832f2028fa2dfe904df252",
      "signal_patterns": [
        "VSYNC-sf"
      ],
      "skill_id": "consumer_jank_detection",
      "source": {
        "path": "backend/skills/atomic/consumer_jank_detection.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1cabbcaffac2059d6095ba3df586dcd0990a0a9879057a8e8d44f7c3bf3756fc"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.timeline",
          "android.frames.jank_type"
        ],
        "drops": [],
        "required_tables": [
          "actual_frame_timeline_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "presentation_cadence_audit",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "layer_name",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "frame_timeline"
        ]
      },
      "id": "consumer_jank_detection/consumer_jank_frames",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/consumer_jank_detection/consumer_jank_frames.sql",
      "sha256": "c17e9508b0369f70f4da883937594ee6eb70f43c3e2b4feaea1cbf9afe313141",
      "signal_patterns": [
        "VSYNC-sf"
      ],
      "skill_id": "consumer_jank_detection",
      "source": {
        "path": "backend/skills/atomic/consumer_jank_detection.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1cabbcaffac2059d6095ba3df586dcd0990a0a9879057a8e8d44f7c3bf3756fc"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.timeline",
          "android.frames.jank_type"
        ],
        "drops": [],
        "required_tables": [
          "actual_frame_timeline_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "consumer_jank_frames",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "layer_name",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "frame_timeline"
        ]
      },
      "id": "consumer_jank_detection/consumer_jank_summary",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/consumer_jank_detection/consumer_jank_summary.sql",
      "sha256": "18ac62f7e59cc680031d847697029ea4e2ef19cd8ca3215fe520091390d31cc5",
      "signal_patterns": [
        "VSYNC-sf"
      ],
      "skill_id": "consumer_jank_detection",
      "source": {
        "path": "backend/skills/atomic/consumer_jank_detection.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1cabbcaffac2059d6095ba3df586dcd0990a0a9879057a8e8d44f7c3bf3756fc"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.timeline",
          "android.frames.jank_type"
        ],
        "drops": [],
        "required_tables": [
          "actual_frame_timeline_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "consumer_jank_summary",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "layer_name",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "frame_timeline"
        ]
      },
      "id": "consumer_jank_detection/jank_severity_distribution",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/consumer_jank_detection/jank_severity_distribution.sql",
      "sha256": "bf84851164958f8bfd9b9edf96072dc22cb3deea6466e3593161c200f4d0e2e9",
      "signal_patterns": [
        "VSYNC-sf"
      ],
      "skill_id": "consumer_jank_detection",
      "source": {
        "path": "backend/skills/atomic/consumer_jank_detection.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1cabbcaffac2059d6095ba3df586dcd0990a0a9879057a8e8d44f7c3bf3756fc"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.timeline",
          "android.frames.jank_type"
        ],
        "drops": [],
        "required_tables": [
          "actual_frame_timeline_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "jank_severity_distribution",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "layer_name",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "consumer_jank_detection"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_analysis/get_process",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_analysis/get_process.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "e0eec1841aaa543a8d9ba7b1fab916fa60c9edadada99163d134a6ad039827ea",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "%.%"
      ],
      "skill_id": "cpu_analysis",
      "source": {
        "path": "backend/skills/composite/cpu_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "d92fc12306d640e35692ee32b71bec6aa951ed61f3d8f5b0f4f24b2bafacc9af"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "get_process",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/system_sched_spans.sql",
            "source_sha256": "ebcdcc6f476c4109051e817bcd107b1e45351faea14ff238ba76fb3f53b0b032"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_analysis/core_type_stats",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_analysis/core_type_stats.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "16064000b4c63e52832ae234ebb8d34237c7c73997aa1f9666f8ba57222b983f",
      "signal_patterns": [],
      "skill_id": "cpu_analysis",
      "source": {
        "path": "backend/skills/composite/cpu_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "d92fc12306d640e35692ee32b71bec6aa951ed61f3d8f5b0f4f24b2bafacc9af"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "core_type_stats",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/system_sched_spans.sql",
            "source_sha256": "ebcdcc6f476c4109051e817bcd107b1e45351faea14ff238ba76fb3f53b0b032"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_analysis/thread_cpu_usage",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_analysis/thread_cpu_usage.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "9f1b2f8c56f7fa991387131c9abb9741aa4899d1e5460d0b43bbede3ef5ce808",
      "signal_patterns": [],
      "skill_id": "cpu_analysis",
      "source": {
        "path": "backend/skills/composite/cpu_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "d92fc12306d640e35692ee32b71bec6aa951ed61f3d8f5b0f4f24b2bafacc9af"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "thread_cpu_usage",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/system_sched_spans.sql",
            "source_sha256": "ebcdcc6f476c4109051e817bcd107b1e45351faea14ff238ba76fb3f53b0b032"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_analysis/main_thread_states",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_analysis/main_thread_states.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "93d782533bf1d2a4811cf7a1bd7854c96703d219d96f0a277ba7e528ee42ca4f",
      "signal_patterns": [
        "${package}:*"
      ],
      "skill_id": "cpu_analysis",
      "source": {
        "path": "backend/skills/composite/cpu_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "d92fc12306d640e35692ee32b71bec6aa951ed61f3d8f5b0f4f24b2bafacc9af"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "main_thread_states",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/system_thread_state_spans.sql",
            "source_sha256": "40a17843f23e9cd7a249735450ff58accb11c2ecb13ac8c22f3f9ff31bcadaa1"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_analysis/runnable_latency",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_analysis/runnable_latency.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "b0d328810be37be406c60aabb9f5f243c60eb381fb1b21dd2f71271faef483c4",
      "signal_patterns": [
        "${package}:*"
      ],
      "skill_id": "cpu_analysis",
      "source": {
        "path": "backend/skills/composite/cpu_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "d92fc12306d640e35692ee32b71bec6aa951ed61f3d8f5b0f4f24b2bafacc9af"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "runnable_latency",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/system_thread_state_spans.sql",
            "source_sha256": "40a17843f23e9cd7a249735450ff58accb11c2ecb13ac8c22f3f9ff31bcadaa1"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "sched_delay_critical_ms",
          "start_ts"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_analysis/main_thread_cores",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_analysis/main_thread_cores.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "e2251d6a9104cfb5882c2aff91591848bd2b873e7b441200f9cd245ae0793c49",
      "signal_patterns": [],
      "skill_id": "cpu_analysis",
      "source": {
        "path": "backend/skills/composite/cpu_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "d92fc12306d640e35692ee32b71bec6aa951ed61f3d8f5b0f4f24b2bafacc9af"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "main_thread_cores",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/system_sched_spans.sql",
            "source_sha256": "ebcdcc6f476c4109051e817bcd107b1e45351faea14ff238ba76fb3f53b0b032"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_analysis/blocked_functions",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_analysis/blocked_functions.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "a9728005034631305194c3623056bb1ceac8a93b46038abd810feba4c1a89354",
      "signal_patterns": [
        "${package}:*"
      ],
      "skill_id": "cpu_analysis",
      "source": {
        "path": "backend/skills/composite/cpu_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "d92fc12306d640e35692ee32b71bec6aa951ed61f3d8f5b0f4f24b2bafacc9af"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "blocked_functions",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/system_thread_state_spans.sql",
            "source_sha256": "40a17843f23e9cd7a249735450ff58accb11c2ecb13ac8c22f3f9ff31bcadaa1"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/io_blocked_function_families.sql",
            "source_sha256": "8d45506b0b20c30c432f555da5a21e293f3d290c55059f1cd3f508f77df72bb0"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_analysis/cpu_frequency_distribution",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_analysis/cpu_frequency_distribution.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "78bbc7747a2376dbd4984d0b537c2b77dd59df47b4de15e1c46fd1f63583eed6",
      "signal_patterns": [],
      "skill_id": "cpu_analysis",
      "source": {
        "path": "backend/skills/composite/cpu_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "d92fc12306d640e35692ee32b71bec6aa951ed61f3d8f5b0f4f24b2bafacc9af"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "cpu_frequency_distribution",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/system_sched_spans.sql",
            "source_sha256": "ebcdcc6f476c4109051e817bcd107b1e45351faea14ff238ba76fb3f53b0b032"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/system_cpu_frequency_spans.sql",
            "source_sha256": "b874887b2a598182d29b088ea7b350d89687142dc07e8fb1c9dbc771c54b48b1"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_analysis/wakeup_chain",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_analysis/wakeup_chain.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "77ae188d12233b6182099f9abb95d85c969dc8ebabd0ceb3e0e343184ccda3ef",
      "signal_patterns": [
        "${package}:*"
      ],
      "skill_id": "cpu_analysis",
      "source": {
        "path": "backend/skills/composite/cpu_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "d92fc12306d640e35692ee32b71bec6aa951ed61f3d8f5b0f4f24b2bafacc9af"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "wakeup_chain",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/system_thread_state_spans.sql",
            "source_sha256": "40a17843f23e9cd7a249735450ff58accb11c2ecb13ac8c22f3f9ff31bcadaa1"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_analysis/cache_counter_check",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_analysis/cache_counter_check.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "a0f7227e4af74900b1f867eb896779165e47f491f20f8796246f44a72ec6de5f",
      "signal_patterns": [],
      "skill_id": "cpu_analysis",
      "source": {
        "path": "backend/skills/composite/cpu_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "d92fc12306d640e35692ee32b71bec6aa951ed61f3d8f5b0f4f24b2bafacc9af"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "cache_counter_check",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "cpu_analysis"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_anomalous_threads_in_range/anomalous_threads",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_anomalous_threads_in_range/anomalous_threads.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "4b90bcbf22a1d37022b8d0ed008c48ae9c7f9de5c361348b8478b1f51352365a",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "cpu_anomalous_threads_in_range",
      "source": {
        "path": "backend/skills/atomic/cpu_anomalous_threads_in_range.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "ebd323de6763d2610995f371f900c448a892c16151ffa0bec43f440e1c702042"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.process_metadata"
        ],
        "drops": [],
        "required_tables": [
          "sched_slice",
          "thread"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "anomalous_threads",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/system_sched_spans.sql",
            "source_sha256": "ebcdcc6f476c4109051e817bcd107b1e45351faea14ff238ba76fb3f53b0b032"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/actor_class_labels.sql",
            "source_sha256": "b28f4189f24c03662c31a826cb3e854e0855e0d93f6f25b2dcf9b7dcef44287d"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "kernel_daemon_share_pct",
          "package",
          "process_name",
          "spin_avg_slice_us",
          "spin_switches_per_s",
          "start_ts",
          "sustained_pct",
          "top_n",
          "waker_per_s"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "cpu_anomalous_threads_in_range"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_cluster_load_in_range/cluster_load",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_cluster_load_in_range/cluster_load.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "e9b213ac51a1de0779e2d7812d021f4160b742b665428f846dac24ad8ad082c1",
      "signal_patterns": [],
      "skill_id": "cpu_cluster_load_in_range",
      "source": {
        "path": "backend/skills/atomic/cpu_cluster_load_in_range.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "a5751409d29cad0c6725683a9f78734180f05324aafb0e6a12a212b00eecdf09"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [
          "_cpu_topology"
        ],
        "setup_queries": [
          "cpu_topology_view/create_topology_view"
        ]
      },
      "step_id": "cluster_load",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/cpu_cluster_load.sql",
            "source_sha256": "a9ab01351851503d5705f404e4b4a9188f770df28bd9f458bc4b99b7aef852a3"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "cpu_cluster_load_in_range"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_cluster_mapping_view/cluster_mapping",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_cluster_mapping_view/cluster_mapping.sql",
      "sha256": "7c4036b01c7238bf6b8c8d26875067ba00e12c360da7660e102755bac68e39e8",
      "signal_patterns": [],
      "skill_id": "cpu_cluster_mapping_view",
      "source": {
        "path": "backend/skills/atomic/cpu_cluster_mapping_view.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "c5d603b71661230ea7d4c4b626a8e6e9d6ecb6844f83d8d215feb9429bf19fb1"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.cpu.cluster_type"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "cluster_mapping",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "cpu_cluster_mapping_view"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "cpu_frequency_limit_attribution/data_check",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_frequency_limit_attribution/data_check.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "cf16c7ad2c41b6a737fbf01089790909f69ef895f453c5dbb63696a8a00ba3f4",
      "signal_patterns": [],
      "skill_id": "cpu_frequency_limit_attribution",
      "source": {
        "path": "backend/skills/composite/cpu_frequency_limit_attribution.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "758e7664b2091d3e128ef1d06d88c4a311526ec85bac8f6db15d7dc1510901e3"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "android.process_metadata"
        ],
        "drops": [],
        "required_tables": [
          "counter",
          "counter_track",
          "cpu_counter_track"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "data_check",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/system_cpu_freq_limit_spans.sql",
            "source_sha256": "3689906e3930685041f01a527cb96dbc2f01af2f2791cf8bd3cafe7246b124c5"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/thermal_cooling_spans.sql",
            "source_sha256": "69300310fc849f085be328db556111a8f5062ed79194b21bfe7884f56ea1d273"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/thermal_cdev_policy_association.sql",
            "source_sha256": "a7f0ae1eeb10af4c06192c284698f2c040677ccb834f82241cfb8959ab643ea2"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "cdev_policy_min_pair_pct",
          "cdev_policy_min_transitions",
          "cdev_policy_pair_ms"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "cpu_frequency_limit_attribution/analysis_window",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_frequency_limit_attribution/analysis_window.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "c8ec6611aa92f0174ea9bcd451e58c235452a4b26d01a9d76293da5e8ef4b97e",
      "signal_patterns": [],
      "skill_id": "cpu_frequency_limit_attribution",
      "source": {
        "path": "backend/skills/composite/cpu_frequency_limit_attribution.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "758e7664b2091d3e128ef1d06d88c4a311526ec85bac8f6db15d7dc1510901e3"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "android.process_metadata"
        ],
        "drops": [],
        "required_tables": [
          "counter",
          "counter_track",
          "cpu_counter_track"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "analysis_window",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "cpu_frequency_limit_attribution/episodes",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_frequency_limit_attribution/episodes.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "2cf6ed1819dd10395bd90093f83935e6d8714f8191f603512dbf5a70e811aca1",
      "signal_patterns": [],
      "skill_id": "cpu_frequency_limit_attribution",
      "source": {
        "path": "backend/skills/composite/cpu_frequency_limit_attribution.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "758e7664b2091d3e128ef1d06d88c4a311526ec85bac8f6db15d7dc1510901e3"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "android.process_metadata"
        ],
        "drops": [],
        "required_tables": [
          "counter",
          "counter_track",
          "cpu_counter_track"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "episodes",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/observed_data_bounds.sql",
            "source_sha256": "70d1e84a0c64ad9d2dd99ff0ccedcafb38ff8612e75dafea6d41d82e2b9045f6"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/system_sched_spans.sql",
            "source_sha256": "ebcdcc6f476c4109051e817bcd107b1e45351faea14ff238ba76fb3f53b0b032"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/system_cpu_freq_limit_spans.sql",
            "source_sha256": "3689906e3930685041f01a527cb96dbc2f01af2f2791cf8bd3cafe7246b124c5"
          },
          {
            "order": 3,
            "source_path": "backend/skills/fragments/system_cpu_freq_limit_episodes.sql",
            "source_sha256": "22fe16eba8f34aa4be55db1b7d3ed1b3c3802147d3817cc667575dc7dcdce83c"
          }
        ],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "cdev_policy_min_pair_pct",
          "cdev_policy_min_transitions",
          "cdev_policy_pair_ms",
          "cooling_coincidence_ms",
          "episode_drop_pct",
          "kernel_daemon_share_pct",
          "lookback_ms",
          "max_episodes",
          "merge_gap_ms",
          "package",
          "process_name",
          "spin_avg_slice_us",
          "spin_switches_per_s",
          "sustained_pct",
          "top_n",
          "waker_per_s",
          "who_window_ms"
        ],
        "result_dependencies": [],
        "result_references": [
          "analysis_window"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "cpu_frequency_limit_attribution/attribution_summary",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_frequency_limit_attribution/attribution_summary.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "f3aebf483a15e62996b8a1e803a8c9845de04ac47ea3884eb999c74d988b89de",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "cpu_frequency_limit_attribution",
      "source": {
        "path": "backend/skills/composite/cpu_frequency_limit_attribution.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "758e7664b2091d3e128ef1d06d88c4a311526ec85bac8f6db15d7dc1510901e3"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "android.process_metadata"
        ],
        "drops": [],
        "required_tables": [
          "counter",
          "counter_track",
          "cpu_counter_track"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "attribution_summary",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/system_sched_spans.sql",
            "source_sha256": "ebcdcc6f476c4109051e817bcd107b1e45351faea14ff238ba76fb3f53b0b032"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/system_cpu_freq_limit_spans.sql",
            "source_sha256": "3689906e3930685041f01a527cb96dbc2f01af2f2791cf8bd3cafe7246b124c5"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/system_cpu_freq_limit_episodes.sql",
            "source_sha256": "22fe16eba8f34aa4be55db1b7d3ed1b3c3802147d3817cc667575dc7dcdce83c"
          },
          {
            "order": 3,
            "source_path": "backend/skills/fragments/thermal_cooling_spans.sql",
            "source_sha256": "69300310fc849f085be328db556111a8f5062ed79194b21bfe7884f56ea1d273"
          },
          {
            "order": 4,
            "source_path": "backend/skills/fragments/thermal_cdev_policy_association.sql",
            "source_sha256": "a7f0ae1eeb10af4c06192c284698f2c040677ccb834f82241cfb8959ab643ea2"
          },
          {
            "order": 5,
            "source_path": "backend/skills/fragments/thermal_signal_signatures.sql",
            "source_sha256": "4fcdab426ef0663f5d51035fed7e1aef7147289fcb8f24d87313d4eddcd571ae"
          },
          {
            "order": 6,
            "source_path": "backend/skills/fragments/system_cpu_freq_limit_episode_verdicts.sql",
            "source_sha256": "5953d349d849c13b220d38a3e101f0001030bcaa844c2066cff7061e1dda6d59"
          },
          {
            "order": 7,
            "source_path": "backend/skills/fragments/actor_class_labels.sql",
            "source_sha256": "b28f4189f24c03662c31a826cb3e854e0855e0d93f6f25b2dcf9b7dcef44287d"
          }
        ],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "cdev_policy_min_pair_pct",
          "cdev_policy_min_transitions",
          "cdev_policy_pair_ms",
          "cooling_coincidence_ms",
          "episode_drop_pct",
          "merge_gap_ms",
          "package",
          "process_name",
          "who_window_ms"
        ],
        "result_dependencies": [
          "episode_rows"
        ],
        "result_references": [
          "analysis_window",
          "episode_rows"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "cpu_frequency_limit_attribution/vendor_signal_discovery",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_frequency_limit_attribution/vendor_signal_discovery.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "d3af63dba2409ea67273af736b4288595c5fad2770dee9ad30fc89c446f5aa01",
      "signal_patterns": [],
      "skill_id": "cpu_frequency_limit_attribution",
      "source": {
        "path": "backend/skills/composite/cpu_frequency_limit_attribution.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "758e7664b2091d3e128ef1d06d88c4a311526ec85bac8f6db15d7dc1510901e3"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "android.process_metadata"
        ],
        "drops": [],
        "required_tables": [
          "counter",
          "counter_track",
          "cpu_counter_track"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "vendor_signal_discovery",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/thermal_signal_signatures.sql",
            "source_sha256": "4fcdab426ef0663f5d51035fed7e1aef7147289fcb8f24d87313d4eddcd571ae"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "max_discovery_rows"
        ],
        "result_dependencies": [],
        "result_references": [
          "analysis_window"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "cpu_frequency_limit_attribution/no_limit_capture_advice",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_frequency_limit_attribution/no_limit_capture_advice.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "c9f5790379b7268c2c03f74f892ae561209d06c134e3790ddc224506feb5a47b",
      "signal_patterns": [],
      "skill_id": "cpu_frequency_limit_attribution",
      "source": {
        "path": "backend/skills/composite/cpu_frequency_limit_attribution.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "758e7664b2091d3e128ef1d06d88c4a311526ec85bac8f6db15d7dc1510901e3"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "android.process_metadata"
        ],
        "drops": [],
        "required_tables": [
          "counter",
          "counter_track",
          "cpu_counter_track"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "no_limit_capture_advice",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/system_cpu_freq_limit_spans.sql",
            "source_sha256": "3689906e3930685041f01a527cb96dbc2f01af2f2791cf8bd3cafe7246b124c5"
          }
        ],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "cpu_frequency_limit_attribution"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "cpu_frequency_limit_episode/episode_windows",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_frequency_limit_episode/episode_windows.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "42cc8de452d2b042239630485e95e1e7972b708697c8400b22f18a0aa8a632c6",
      "signal_patterns": [],
      "skill_id": "cpu_frequency_limit_episode",
      "source": {
        "path": "backend/skills/composite/cpu_frequency_limit_episode.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "8d75cefe0155fc514370fc541fbd0b54aa5c81c152e666ea0dde0514011da4cb"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "android.process_metadata"
        ],
        "drops": [],
        "required_tables": [
          "counter",
          "counter_track",
          "sched_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "episode_windows",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/observed_data_bounds.sql",
            "source_sha256": "70d1e84a0c64ad9d2dd99ff0ccedcafb38ff8612e75dafea6d41d82e2b9045f6"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "core_type",
          "episode_end_ts",
          "episode_id",
          "episode_start_ts",
          "lookback_ms",
          "policy_cpu",
          "who_window_ms"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "cpu_frequency_limit_episode/who_cooling",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_frequency_limit_episode/who_cooling.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "d9e75af87087c0fb7d05b995627c85fc52301ac6f25e2b20467531778da5f23d",
      "signal_patterns": [],
      "skill_id": "cpu_frequency_limit_episode",
      "source": {
        "path": "backend/skills/composite/cpu_frequency_limit_episode.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "8d75cefe0155fc514370fc541fbd0b54aa5c81c152e666ea0dde0514011da4cb"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "android.process_metadata"
        ],
        "drops": [],
        "required_tables": [
          "counter",
          "counter_track",
          "sched_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "who_cooling",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/system_cpu_freq_limit_spans.sql",
            "source_sha256": "3689906e3930685041f01a527cb96dbc2f01af2f2791cf8bd3cafe7246b124c5"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/system_cpu_freq_limit_episodes.sql",
            "source_sha256": "22fe16eba8f34aa4be55db1b7d3ed1b3c3802147d3817cc667575dc7dcdce83c"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/thermal_cooling_spans.sql",
            "source_sha256": "69300310fc849f085be328db556111a8f5062ed79194b21bfe7884f56ea1d273"
          },
          {
            "order": 3,
            "source_path": "backend/skills/fragments/thermal_cdev_policy_association.sql",
            "source_sha256": "a7f0ae1eeb10af4c06192c284698f2c040677ccb834f82241cfb8959ab643ea2"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "cdev_policy_min_pair_pct",
          "cdev_policy_min_transitions",
          "cdev_policy_pair_ms",
          "episode_drop_pct",
          "episode_start_ts",
          "merge_gap_ms",
          "policy_cpu"
        ],
        "result_dependencies": [],
        "result_references": [
          "episode_windows"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "cpu_frequency_limit_episode/who_daemon",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_frequency_limit_episode/who_daemon.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "e1a781b85fd2384b1e5745cc0d93a43551cdf2fbe6878ae7e20ae407fe64fab8",
      "signal_patterns": [],
      "skill_id": "cpu_frequency_limit_episode",
      "source": {
        "path": "backend/skills/composite/cpu_frequency_limit_episode.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "8d75cefe0155fc514370fc541fbd0b54aa5c81c152e666ea0dde0514011da4cb"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "android.process_metadata"
        ],
        "drops": [],
        "required_tables": [
          "counter",
          "counter_track",
          "sched_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "who_daemon",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/thermal_signal_signatures.sql",
            "source_sha256": "4fcdab426ef0663f5d51035fed7e1aef7147289fcb8f24d87313d4eddcd571ae"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "episode_start_ts"
        ],
        "result_dependencies": [],
        "result_references": [
          "episode_windows"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "cpu_frequency_limit_episode/temperature_context",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_frequency_limit_episode/temperature_context.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "6fff43570a7225e1bce24d70afb3fe649c8673e93f0207247958d9dbed453ece",
      "signal_patterns": [],
      "skill_id": "cpu_frequency_limit_episode",
      "source": {
        "path": "backend/skills/composite/cpu_frequency_limit_episode.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "8d75cefe0155fc514370fc541fbd0b54aa5c81c152e666ea0dde0514011da4cb"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "android.process_metadata"
        ],
        "drops": [],
        "required_tables": [
          "counter",
          "counter_track",
          "sched_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "temperature_context",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/thermal_sample_quality.sql",
            "source_sha256": "6ff64e0064debba52261d28e441265e5227603078075781213a721d327ea889d"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [
          "episode_windows"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "cpu_frequency_limit_episode/non_cpu_heat_context",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_frequency_limit_episode/non_cpu_heat_context.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "eea07f223910a6ca6700cf4af6ec4b1b065815f4ceb9f1831cee657fd6187e1a",
      "signal_patterns": [
        "gpufreq"
      ],
      "skill_id": "cpu_frequency_limit_episode",
      "source": {
        "path": "backend/skills/composite/cpu_frequency_limit_episode.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "8d75cefe0155fc514370fc541fbd0b54aa5c81c152e666ea0dde0514011da4cb"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "android.process_metadata"
        ],
        "drops": [],
        "required_tables": [
          "counter",
          "counter_track",
          "sched_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "non_cpu_heat_context",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/thermal_signal_signatures.sql",
            "source_sha256": "4fcdab426ef0663f5d51035fed7e1aef7147289fcb8f24d87313d4eddcd571ae"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/gpu_frequency_intervals.sql",
            "source_sha256": "2bd8dac125b274ab3a3966e9f43ed780d0eef389b2eb5c0ee60e82fbfb5d6cba"
          }
        ],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [
          "episode_windows"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "cpu_frequency_limit_episode/who_verdict",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_frequency_limit_episode/who_verdict.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "a2b36d8ee8e29dd04fef9cf794bd6b4832635837ae6cfc2151570614c8928908",
      "signal_patterns": [],
      "skill_id": "cpu_frequency_limit_episode",
      "source": {
        "path": "backend/skills/composite/cpu_frequency_limit_episode.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "8d75cefe0155fc514370fc541fbd0b54aa5c81c152e666ea0dde0514011da4cb"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "android.process_metadata"
        ],
        "drops": [],
        "required_tables": [
          "counter",
          "counter_track",
          "sched_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "who_verdict",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/system_sched_spans.sql",
            "source_sha256": "ebcdcc6f476c4109051e817bcd107b1e45351faea14ff238ba76fb3f53b0b032"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/system_cpu_freq_limit_spans.sql",
            "source_sha256": "3689906e3930685041f01a527cb96dbc2f01af2f2791cf8bd3cafe7246b124c5"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/system_cpu_freq_limit_episodes.sql",
            "source_sha256": "22fe16eba8f34aa4be55db1b7d3ed1b3c3802147d3817cc667575dc7dcdce83c"
          },
          {
            "order": 3,
            "source_path": "backend/skills/fragments/thermal_cooling_spans.sql",
            "source_sha256": "69300310fc849f085be328db556111a8f5062ed79194b21bfe7884f56ea1d273"
          },
          {
            "order": 4,
            "source_path": "backend/skills/fragments/thermal_cdev_policy_association.sql",
            "source_sha256": "a7f0ae1eeb10af4c06192c284698f2c040677ccb834f82241cfb8959ab643ea2"
          },
          {
            "order": 5,
            "source_path": "backend/skills/fragments/thermal_signal_signatures.sql",
            "source_sha256": "4fcdab426ef0663f5d51035fed7e1aef7147289fcb8f24d87313d4eddcd571ae"
          },
          {
            "order": 6,
            "source_path": "backend/skills/fragments/system_cpu_freq_limit_episode_verdicts.sql",
            "source_sha256": "5953d349d849c13b220d38a3e101f0001030bcaa844c2066cff7061e1dda6d59"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "cdev_policy_min_pair_pct",
          "cdev_policy_min_transitions",
          "cdev_policy_pair_ms",
          "cooling_coincidence_ms",
          "episode_drop_pct",
          "episode_end_ts",
          "episode_start_ts",
          "merge_gap_ms",
          "policy_cpu",
          "trace_episode_id",
          "who_window_ms",
          "window_end_ts",
          "window_start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "cpu_frequency_limit_episode/limit_onsets",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_frequency_limit_episode/limit_onsets.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "617cbe2b978eccd2476a654d368f92dd203aed63c0884a6c67289e69e7927c32",
      "signal_patterns": [],
      "skill_id": "cpu_frequency_limit_episode",
      "source": {
        "path": "backend/skills/composite/cpu_frequency_limit_episode.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "8d75cefe0155fc514370fc541fbd0b54aa5c81c152e666ea0dde0514011da4cb"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "android.process_metadata"
        ],
        "drops": [],
        "required_tables": [
          "counter",
          "counter_track",
          "sched_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "limit_onsets",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/system_sched_spans.sql",
            "source_sha256": "ebcdcc6f476c4109051e817bcd107b1e45351faea14ff238ba76fb3f53b0b032"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/system_cpu_freq_limit_spans.sql",
            "source_sha256": "3689906e3930685041f01a527cb96dbc2f01af2f2791cf8bd3cafe7246b124c5"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/system_cpu_freq_limit_episodes.sql",
            "source_sha256": "22fe16eba8f34aa4be55db1b7d3ed1b3c3802147d3817cc667575dc7dcdce83c"
          },
          {
            "order": 3,
            "source_path": "backend/skills/fragments/thermal_cooling_spans.sql",
            "source_sha256": "69300310fc849f085be328db556111a8f5062ed79194b21bfe7884f56ea1d273"
          },
          {
            "order": 4,
            "source_path": "backend/skills/fragments/thermal_cdev_policy_association.sql",
            "source_sha256": "a7f0ae1eeb10af4c06192c284698f2c040677ccb834f82241cfb8959ab643ea2"
          },
          {
            "order": 5,
            "source_path": "backend/skills/fragments/thermal_signal_signatures.sql",
            "source_sha256": "4fcdab426ef0663f5d51035fed7e1aef7147289fcb8f24d87313d4eddcd571ae"
          },
          {
            "order": 6,
            "source_path": "backend/skills/fragments/system_cpu_freq_limit_episode_verdicts.sql",
            "source_sha256": "5953d349d849c13b220d38a3e101f0001030bcaa844c2066cff7061e1dda6d59"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "cdev_policy_min_pair_pct",
          "cdev_policy_min_transitions",
          "cdev_policy_pair_ms",
          "cooling_coincidence_ms",
          "episode_drop_pct",
          "episode_end_ts",
          "episode_start_ts",
          "merge_gap_ms",
          "who_window_ms",
          "window_end_ts",
          "window_start_ts"
        ],
        "result_dependencies": [
          "who_verdict"
        ],
        "result_references": [
          "who_verdict"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "cpu_frequency_limit_episode"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "cpu_freq_limit_timeline/limit_data_check",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_freq_limit_timeline/limit_data_check.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "e57fa61e3686a2586f92f386873e0df15e1ceebd5db3f5a25e898dff5fb432e2",
      "signal_patterns": [],
      "skill_id": "cpu_freq_limit_timeline",
      "source": {
        "path": "backend/skills/atomic/cpu_freq_limit_timeline.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "352702371456ef9840b8601360663914d0190087759e74f94650be5ffdea8483"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [
          "cpu_counter_track",
          "counter"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "limit_data_check",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/system_cpu_freq_limit_spans.sql",
            "source_sha256": "3689906e3930685041f01a527cb96dbc2f01af2f2791cf8bd3cafe7246b124c5"
          }
        ],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "cpu_freq_limit_timeline/limit_summary",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_freq_limit_timeline/limit_summary.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "4f8933cdb2fd6c76030929d894555d059fcff0baf38c321e4471b5158e67a9e6",
      "signal_patterns": [],
      "skill_id": "cpu_freq_limit_timeline",
      "source": {
        "path": "backend/skills/atomic/cpu_freq_limit_timeline.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "352702371456ef9840b8601360663914d0190087759e74f94650be5ffdea8483"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [
          "cpu_counter_track",
          "counter"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "limit_summary",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/system_sched_spans.sql",
            "source_sha256": "ebcdcc6f476c4109051e817bcd107b1e45351faea14ff238ba76fb3f53b0b032"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/system_cpu_freq_limit_spans.sql",
            "source_sha256": "3689906e3930685041f01a527cb96dbc2f01af2f2791cf8bd3cafe7246b124c5"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "cpu_freq_limit_timeline/limit_episodes",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_freq_limit_timeline/limit_episodes.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "6cd21995685d2b804b81aab2ae014a907d14d1fc551b5fec8d2b3092e06fa860",
      "signal_patterns": [],
      "skill_id": "cpu_freq_limit_timeline",
      "source": {
        "path": "backend/skills/atomic/cpu_freq_limit_timeline.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "352702371456ef9840b8601360663914d0190087759e74f94650be5ffdea8483"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [
          "cpu_counter_track",
          "counter"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "limit_episodes",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/system_sched_spans.sql",
            "source_sha256": "ebcdcc6f476c4109051e817bcd107b1e45351faea14ff238ba76fb3f53b0b032"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/system_cpu_freq_limit_spans.sql",
            "source_sha256": "3689906e3930685041f01a527cb96dbc2f01af2f2791cf8bd3cafe7246b124c5"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/system_cpu_freq_limit_episodes.sql",
            "source_sha256": "22fe16eba8f34aa4be55db1b7d3ed1b3c3802147d3817cc667575dc7dcdce83c"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "episode_drop_pct",
          "merge_gap_ms",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "cpu_freq_limit_timeline/limit_events",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_freq_limit_timeline/limit_events.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "6b96417f7ce9f9a7177004f44bd487b3b3230b9e45949ce050b4525025c42007",
      "signal_patterns": [],
      "skill_id": "cpu_freq_limit_timeline",
      "source": {
        "path": "backend/skills/atomic/cpu_freq_limit_timeline.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "352702371456ef9840b8601360663914d0190087759e74f94650be5ffdea8483"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [
          "cpu_counter_track",
          "counter"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "limit_events",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/system_sched_spans.sql",
            "source_sha256": "ebcdcc6f476c4109051e817bcd107b1e45351faea14ff238ba76fb3f53b0b032"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/system_cpu_freq_limit_spans.sql",
            "source_sha256": "3689906e3930685041f01a527cb96dbc2f01af2f2791cf8bd3cafe7246b124c5"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/system_cpu_freq_limit_episodes.sql",
            "source_sha256": "22fe16eba8f34aa4be55db1b7d3ed1b3c3802147d3817cc667575dc7dcdce83c"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "episode_drop_pct",
          "merge_gap_ms",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "cpu_freq_limit_timeline/limit_unavailable",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_freq_limit_timeline/limit_unavailable.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "396e15affb5fb0c95e3233cac56ba364f462cdd186d3fbadd764cb46c7f642f2",
      "signal_patterns": [],
      "skill_id": "cpu_freq_limit_timeline",
      "source": {
        "path": "backend/skills/atomic/cpu_freq_limit_timeline.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "352702371456ef9840b8601360663914d0190087759e74f94650be5ffdea8483"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [
          "cpu_counter_track",
          "counter"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "limit_unavailable",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/system_cpu_freq_limit_spans.sql",
            "source_sha256": "3689906e3930685041f01a527cb96dbc2f01af2f2791cf8bd3cafe7246b124c5"
          }
        ],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "cpu_freq_limit_timeline"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_freq_residency_summary/freq_residency",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_freq_residency_summary/freq_residency.sql",
      "sha256": "4a722ca6acbd56495e620bea43f66eabff1627d6a1174e2c9cd6558605da076d",
      "signal_patterns": [],
      "skill_id": "cpu_freq_residency_summary",
      "source": {
        "path": "backend/skills/atomic/cpu_freq_residency_summary.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "551f4b3dae5db3b84e15a017225eeb4399a0a9824fe59a04fbf47a30395103d5"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "android.cpu.cluster_type"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "freq_residency",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "cpu_freq_residency_summary"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "cpu_freq_timeline/cpu_freq_changes",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_freq_timeline/cpu_freq_changes.sql",
      "sha256": "550782817008cf16ecfe0cae888127475a4fa9ae24345282795252ad30ebd702",
      "signal_patterns": [
        "cpufreq"
      ],
      "skill_id": "cpu_freq_timeline",
      "source": {
        "path": "backend/skills/atomic/cpu_freq_timeline.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "b3b383db99879dcd16010de03b51abaac56a2cbf7df1973e994af4f7ac7aeb61"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "cpu_counter_track",
          "counter"
        ],
        "requires": [
          "_cpu_topology"
        ],
        "setup_queries": [
          "cpu_topology_view/create_topology_view"
        ]
      },
      "step_id": "cpu_freq_changes",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "cpu_freq_timeline/cpu_freq_summary",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_freq_timeline/cpu_freq_summary.sql",
      "sha256": "90c692a45cf49abe2396508e583def4fd6bfab1e6dcc71bd75023a37b4bf747b",
      "signal_patterns": [
        "cpufreq"
      ],
      "skill_id": "cpu_freq_timeline",
      "source": {
        "path": "backend/skills/atomic/cpu_freq_timeline.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "b3b383db99879dcd16010de03b51abaac56a2cbf7df1973e994af4f7ac7aeb61"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "cpu_counter_track",
          "counter"
        ],
        "requires": [
          "_cpu_topology"
        ],
        "setup_queries": [
          "cpu_topology_view/create_topology_view"
        ]
      },
      "step_id": "cpu_freq_summary",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "cpu_freq_timeline"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_idle_analysis/root",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_idle_analysis/query.sql",
      "sha256": "adf8cd130c5b501a3ed45f95b147edd3089a837171ae3c82b647b6a72f3c25c2",
      "signal_patterns": [
        "cpuidle"
      ],
      "skill_id": "cpu_idle_analysis",
      "source": {
        "path": "backend/skills/atomic/cpu_idle_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "231e8ce685c178ba67e1e32c7f5fcdb25ba5b5b0b0773af5145ca0572d6b4861"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "cpu_ids",
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "cpu_idle_analysis"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_idle_state_residency/idle_residency",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_idle_state_residency/idle_residency.sql",
      "sha256": "37ac387aa8a13b19e79d4dd8822a74b4eb5eae0de40c399d400302359134c8a8",
      "signal_patterns": [],
      "skill_id": "cpu_idle_state_residency",
      "source": {
        "path": "backend/skills/atomic/cpu_idle_state_residency.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "7ca1a5633d514d72c2e841694bf0c3eb19be753350fdd1168e412761c8337eec"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.idle"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "idle_residency",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "cpu_idle_state_residency"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_load_in_range/cpu_utilization",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_load_in_range/cpu_utilization.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "1f089c1e3cfde31c56ea452e9965cb2be8fd0a7bad8412cb5307d28871ebf125",
      "signal_patterns": [],
      "skill_id": "cpu_load_in_range",
      "source": {
        "path": "backend/skills/atomic/cpu_load_in_range.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1b8c48740c33db268d4dd30f2d4e9d0bdcb254f3439852bbaaec2ff0a373ba48"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "sched_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "cpu_utilization",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/system_sched_spans.sql",
            "source_sha256": "ebcdcc6f476c4109051e817bcd107b1e45351faea14ff238ba76fb3f53b0b032"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_load_in_range/runqueue_depth",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_load_in_range/runqueue_depth.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "21f53afd00e850dae0f7af353c421f93558d8da40b700fe3593c2e806e0029cb",
      "signal_patterns": [
        "runqueue_length"
      ],
      "skill_id": "cpu_load_in_range",
      "source": {
        "path": "backend/skills/atomic/cpu_load_in_range.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1b8c48740c33db268d4dd30f2d4e9d0bdcb254f3439852bbaaec2ff0a373ba48"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "sched_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "runqueue_depth",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/system_sched_spans.sql",
            "source_sha256": "ebcdcc6f476c4109051e817bcd107b1e45351faea14ff238ba76fb3f53b0b032"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_load_in_range/thread_migrations",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_load_in_range/thread_migrations.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "5bdaa5b49d4245ba96a55c85b6738c89fc3584f244aecdca7565000660d3c49f",
      "signal_patterns": [],
      "skill_id": "cpu_load_in_range",
      "source": {
        "path": "backend/skills/atomic/cpu_load_in_range.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1b8c48740c33db268d4dd30f2d4e9d0bdcb254f3439852bbaaec2ff0a373ba48"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "sched_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "thread_migrations",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/system_sched_spans.sql",
            "source_sha256": "ebcdcc6f476c4109051e817bcd107b1e45351faea14ff238ba76fb3f53b0b032"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "cpu_load_in_range"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_module/frequency_overview",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_module/frequency_overview.sql",
      "sha256": "0ec3d8ecb7ac55fd51fa4c5058e29bb32abb30d10791570396747a9bd18ec457",
      "signal_patterns": [
        "cpufreq"
      ],
      "skill_id": "cpu_module",
      "source": {
        "path": "backend/skills/modules/hardware/cpu_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "4a9d6de50b0314b731792232ca2a3ac602c68e7c870a4e4a3d95f97d9f84a688"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "linux.cpu.idle"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "_cpu_topology"
        ],
        "setup_queries": [
          "cpu_topology_view/create_topology_view"
        ]
      },
      "step_id": "frequency_overview",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_module/throttling_events",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_module/throttling_events.sql",
      "sha256": "125d4229af04001370a3eb6bb85aac51e67eb31731d257541c75c84fa6a31064",
      "signal_patterns": [
        "cpufreq"
      ],
      "skill_id": "cpu_module",
      "source": {
        "path": "backend/skills/modules/hardware/cpu_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "4a9d6de50b0314b731792232ca2a3ac602c68e7c870a4e4a3d95f97d9f84a688"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "linux.cpu.idle"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "throttling_events",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_module/cluster_utilization",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_module/cluster_utilization.sql",
      "sha256": "0f0f5570a104ace93ca989841ecb936c172c6de6f6c83e01818871f3b129f494",
      "signal_patterns": [],
      "skill_id": "cpu_module",
      "source": {
        "path": "backend/skills/modules/hardware/cpu_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "4a9d6de50b0314b731792232ca2a3ac602c68e7c870a4e4a3d95f97d9f84a688"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "linux.cpu.idle"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "_cpu_topology"
        ],
        "setup_queries": [
          "cpu_topology_view/create_topology_view"
        ]
      },
      "step_id": "cluster_utilization",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_module/frequency_distribution",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_module/frequency_distribution.sql",
      "sha256": "83851894a0d1340a2c8bf5bf59f4b88b2c3e7d3a3b75b08cd094e75238412849",
      "signal_patterns": [
        "cpufreq"
      ],
      "skill_id": "cpu_module",
      "source": {
        "path": "backend/skills/modules/hardware/cpu_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "4a9d6de50b0314b731792232ca2a3ac602c68e7c870a4e4a3d95f97d9f84a688"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "linux.cpu.idle"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "_cpu_topology"
        ],
        "setup_queries": [
          "cpu_topology_view/create_topology_view"
        ]
      },
      "step_id": "frequency_distribution",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "cpu_module"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_process_utilization_period/process_util",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_process_utilization_period/process_util.sql",
      "sha256": "9abde50d30a62fc5fd2507b46f8645218a0df6982206c15ac21e58ad026db354",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "cpu_process_utilization_period",
      "source": {
        "path": "backend/skills/atomic/cpu_process_utilization_period.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "78a91e3d2a1f6e5640cfab917092a5c5463f08cb7051b7ab9d63f4f4e8258524"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.utilization.process"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "process_util",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "cpu_process_utilization_period"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_profiling/cpu_usage_overview",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_profiling/cpu_usage_overview.sql",
      "sha256": "7cb0988fb9e76e6ee96c4de88a90339c3a5142c013379ac3e8201e2ac745d190",
      "signal_patterns": [],
      "skill_id": "cpu_profiling",
      "source": {
        "path": "backend/skills/deep/cpu_profiling.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "dce6ebab0c0096f73bc2707459de6af2cb7fefc55f171def6d1303d371c504ae"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "_cpu_topology"
        ],
        "setup_queries": [
          "cpu_topology_view/create_topology_view"
        ]
      },
      "step_id": "cpu_usage_overview",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_profiling/process_cpu_time",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_profiling/process_cpu_time.sql",
      "sha256": "45f2412c95387b8544162ff42ddb0aa4065e8a070e8330e7dc6d5317ebf35c99",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "cpu_profiling",
      "source": {
        "path": "backend/skills/deep/cpu_profiling.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "dce6ebab0c0096f73bc2707459de6af2cb7fefc55f171def6d1303d371c504ae"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "process_cpu_time",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "min_runtime_ms",
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_profiling/thread_cpu_time",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_profiling/thread_cpu_time.sql",
      "sha256": "afb72a4832b777216efb0f0cd2f66077b51d1533b8412191a6a489c1e7311269",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "cpu_profiling",
      "source": {
        "path": "backend/skills/deep/cpu_profiling.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "dce6ebab0c0096f73bc2707459de6af2cb7fefc55f171def6d1303d371c504ae"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "thread_cpu_time",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "min_runtime_ms",
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_profiling/core_distribution",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_profiling/core_distribution.sql",
      "sha256": "bf60d8a08ddc9eae35f986096fa51e6f3eedf10241223ed4535f7536dd8e3901",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "cpu_profiling",
      "source": {
        "path": "backend/skills/deep/cpu_profiling.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "dce6ebab0c0096f73bc2707459de6af2cb7fefc55f171def6d1303d371c504ae"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "_cpu_topology"
        ],
        "setup_queries": [
          "cpu_topology_view/create_topology_view"
        ]
      },
      "step_id": "core_distribution",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "min_runtime_ms",
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_profiling/scheduling_latency",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_profiling/scheduling_latency.sql",
      "sha256": "2fe1e3e0fc376947b11ebd47106e015bc3e2142af36a1e393744c189f9e4ba09",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "cpu_profiling",
      "source": {
        "path": "backend/skills/deep/cpu_profiling.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "dce6ebab0c0096f73bc2707459de6af2cb7fefc55f171def6d1303d371c504ae"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "scheduling_latency",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_profiling/context_switches",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_profiling/context_switches.sql",
      "sha256": "b24c001cd02b50dc4b24dae4db4867980316beedc2730a9d86690c2efaf7891e",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "cpu_profiling",
      "source": {
        "path": "backend/skills/deep/cpu_profiling.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "dce6ebab0c0096f73bc2707459de6af2cb7fefc55f171def6d1303d371c504ae"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "context_switches",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_profiling/cpu_timeline",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_profiling/cpu_timeline.sql",
      "sha256": "4557766f3b8789e9286d9f989cf41dd6674a4511904d982d8311afb9e5051bb9",
      "signal_patterns": [],
      "skill_id": "cpu_profiling",
      "source": {
        "path": "backend/skills/deep/cpu_profiling.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "dce6ebab0c0096f73bc2707459de6af2cb7fefc55f171def6d1303d371c504ae"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "cpu_timeline",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_profiling/profiling_conclusion",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_profiling/profiling_conclusion.sql",
      "sha256": "b6cb99ae270cd3136d7678e8be29575eea07e5154e0130187aa2e806f41dc06b",
      "signal_patterns": [],
      "skill_id": "cpu_profiling",
      "source": {
        "path": "backend/skills/deep/cpu_profiling.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "dce6ebab0c0096f73bc2707459de6af2cb7fefc55f171def6d1303d371c504ae"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "profiling_conclusion",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [
          "core_distribution",
          "scheduling_latency",
          "thread_cpu_time"
        ],
        "result_references": [
          "core_distribution",
          "scheduling_latency",
          "thread_cpu_time"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "cpu_profiling"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_slice_analysis/cpu_time_by_core",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_slice_analysis/cpu_time_by_core.sql",
      "sha256": "cc5372dc86e1690e925d78c14135ffce82696605e417dbf83f1002ff870e668a",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "cpu_slice_analysis",
      "source": {
        "path": "backend/skills/atomic/cpu_slice_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "f7ca8aba38689433e1c2b672a706b0a6a761e7ca0186bbc2280ed92591369b4d"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "sched_slice"
        ],
        "requires": [
          "_cpu_topology"
        ],
        "setup_queries": [
          "cpu_topology_view/create_topology_view"
        ]
      },
      "step_id": "cpu_time_by_core",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "cpu_slice_analysis"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_system_context_in_range/root",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_system_context_in_range/query.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "300f2722eed7516574758090ba21c13320c2a4e90ecb16e0e380a069388fd5d2",
      "signal_patterns": [],
      "skill_id": "cpu_system_context_in_range",
      "source": {
        "path": "backend/skills/atomic/cpu_system_context_in_range.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "474e3b45c7e46c65f6651350cf3496953e90ad29cd0d8c68475f9ba2edb6228e"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/system_sched_spans.sql",
            "source_sha256": "ebcdcc6f476c4109051e817bcd107b1e45351faea14ff238ba76fb3f53b0b032"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/system_cpu_frequency_spans.sql",
            "source_sha256": "b874887b2a598182d29b088ea7b350d89687142dc07e8fb1c9dbc771c54b48b1"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "cpu_system_context_in_range"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_thread_utilization_period/thread_util",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_thread_utilization_period/thread_util.sql",
      "sha256": "4e95fb00356afe0b1f4364c8a7d8ccafd53762c70b77757d27f4a4c38d922374",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "cpu_thread_utilization_period",
      "source": {
        "path": "backend/skills/atomic/cpu_thread_utilization_period.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "33bc2d55f1090e9b8c58eff082eee8ef1ef9f3fe47d0299431a9fb1057af264b"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.utilization.thread"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "thread_util",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "process_name",
          "start_ts",
          "top_n"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "cpu_thread_utilization_period"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_throttling_in_range/limit_evidence",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_throttling_in_range/limit_evidence.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "d99f9fd2d3144e5b37b7f3b52bb00f9a8016884c550c9477f4f75bf3232ed04b",
      "signal_patterns": [],
      "skill_id": "cpu_throttling_in_range",
      "source": {
        "path": "backend/skills/atomic/cpu_throttling_in_range.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "cb86c9d88cd71f79716c0e53b87ed34e4ef068e86e881f0bb0aca434f7a2a757"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "limit_evidence",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/system_sched_spans.sql",
            "source_sha256": "ebcdcc6f476c4109051e817bcd107b1e45351faea14ff238ba76fb3f53b0b032"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/system_cpu_freq_limit_spans.sql",
            "source_sha256": "3689906e3930685041f01a527cb96dbc2f01af2f2791cf8bd3cafe7246b124c5"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/system_cpu_freq_limit_episodes.sql",
            "source_sha256": "22fe16eba8f34aa4be55db1b7d3ed1b3c3802147d3817cc667575dc7dcdce83c"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "episode_drop_pct",
          "merge_gap_ms",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_throttling_in_range/throttle_detection",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_throttling_in_range/throttle_detection.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "fe952ad0e9a9059889721a58e93fe228d3393cfacef822421a2b403bf4de27b7",
      "signal_patterns": [
        "cpufreq"
      ],
      "skill_id": "cpu_throttling_in_range",
      "source": {
        "path": "backend/skills/atomic/cpu_throttling_in_range.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "cb86c9d88cd71f79716c0e53b87ed34e4ef068e86e881f0bb0aca434f7a2a757"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [
          "_cpu_topology"
        ],
        "setup_queries": [
          "cpu_topology_view/create_topology_view"
        ]
      },
      "step_id": "throttle_detection",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [
          "limit_evidence"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "cpu_throttling_in_range"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_time_per_frame/cpu_time",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_time_per_frame/cpu_time.sql",
      "sha256": "52f8c805bbb0c21a53599c9c5667a97c73bcba01d62290fd198a050932fee8c0",
      "signal_patterns": [],
      "skill_id": "cpu_time_per_frame",
      "source": {
        "path": "backend/skills/atomic/cpu_time_per_frame.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "e9ca59dce47fb056113061c19ea44122bff0110e4f6206e0183f65bd96667e1b"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.per_frame_metrics"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "cpu_time",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "cpu_time_per_frame"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_topology_detection/detect_cpu_clusters",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_topology_detection/detect_cpu_clusters.sql",
      "sha256": "fbfbfcd247801fa63a91381cee46daf56aba9a52d42c7d8a804c6b4e65df34f9",
      "signal_patterns": [],
      "skill_id": "cpu_topology_detection",
      "source": {
        "path": "backend/skills/atomic/cpu_topology_detection.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "539074112cd1527ea174f211bee7834c523e137e7c052281ce81e1a3832ca6d0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [
          "_cpu_topology"
        ],
        "setup_queries": [
          "cpu_topology_view/create_topology_view"
        ]
      },
      "step_id": "detect_cpu_clusters",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_topology_detection/cluster_summary",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_topology_detection/cluster_summary.sql",
      "sha256": "6c915b1eadc6c552b0c2c359a1d415b4be1f01cc714e2b237291bc5b0554291f",
      "signal_patterns": [],
      "skill_id": "cpu_topology_detection",
      "source": {
        "path": "backend/skills/atomic/cpu_topology_detection.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "539074112cd1527ea174f211bee7834c523e137e7c052281ce81e1a3832ca6d0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [
          "_cpu_topology"
        ],
        "setup_queries": [
          "cpu_topology_view/create_topology_view"
        ]
      },
      "step_id": "cluster_summary",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_topology_detection/cluster_mapping",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_topology_detection/cluster_mapping.sql",
      "sha256": "f50cfecf0e7b03cbb0b3102b6ebab7960fdf8bc532426a976ebd40cf15796432",
      "signal_patterns": [],
      "skill_id": "cpu_topology_detection",
      "source": {
        "path": "backend/skills/atomic/cpu_topology_detection.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "539074112cd1527ea174f211bee7834c523e137e7c052281ce81e1a3832ca6d0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [
          "_cpu_topology"
        ],
        "setup_queries": [
          "cpu_topology_view/create_topology_view"
        ]
      },
      "step_id": "cluster_mapping",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "cpu_topology_detection"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_topology_view/inspect_existing_topology_object",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_topology_view/inspect_existing_topology_object.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "f0b3591a68429d42ab15ff7e8c67e09f3cc88bf804ee9041e5bc1524a64a1719",
      "signal_patterns": [
        "_cpu_topology"
      ],
      "skill_id": "cpu_topology_view",
      "source": {
        "path": "backend/skills/atomic/cpu_topology_view.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "8e7da2b8aae3dfcf076d784d1dde661efb18385e3c1d951ae6cd2ffa7978a8e6"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [
          "_cpu_topology"
        ],
        "setup_queries": [
          "cpu_topology_view/create_topology_view"
        ]
      },
      "step_id": "inspect_existing_topology_object",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_topology_view/drop_existing_topology_view",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_topology_view/drop_existing_topology_view.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "3f67e953abadea27bee9518829a4f25ca22d5f6681cee3517c8eba790fb0d136",
      "signal_patterns": [],
      "skill_id": "cpu_topology_view",
      "source": {
        "path": "backend/skills/atomic/cpu_topology_view.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "8e7da2b8aae3dfcf076d784d1dde661efb18385e3c1d951ae6cd2ffa7978a8e6"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [
          {
            "kind": "view",
            "name": "_cpu_topology"
          }
        ],
        "required_tables": [],
        "requires": [
          "_cpu_topology"
        ],
        "setup_queries": [
          "cpu_topology_view/create_topology_view"
        ]
      },
      "step_id": "drop_existing_topology_view",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_topology_view/drop_existing_topology_table",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_topology_view/drop_existing_topology_table.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "e7b63249dd82dad5df34c4c77a2fcfc832dcba01985800cbd431bdbeed0f9ce4",
      "signal_patterns": [],
      "skill_id": "cpu_topology_view",
      "source": {
        "path": "backend/skills/atomic/cpu_topology_view.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "8e7da2b8aae3dfcf076d784d1dde661efb18385e3c1d951ae6cd2ffa7978a8e6"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [
          {
            "kind": "table",
            "name": "_cpu_topology"
          }
        ],
        "required_tables": [],
        "requires": [
          "_cpu_topology"
        ],
        "setup_queries": [
          "cpu_topology_view/create_topology_view"
        ]
      },
      "step_id": "drop_existing_topology_table",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_topology_view/create_topology_view",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_topology_view/create_topology_view.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "bf1dacac674eac7b5797c0ce10d0bdf32f09bbc779c139d3397e7857ea5f0338",
      "signal_patterns": [
        "cpufreq"
      ],
      "skill_id": "cpu_topology_view",
      "source": {
        "path": "backend/skills/atomic/cpu_topology_view.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "8e7da2b8aae3dfcf076d784d1dde661efb18385e3c1d951ae6cd2ffa7978a8e6"
      },
      "sql_dependencies": {
        "creates": [
          {
            "kind": "table",
            "name": "_cpu_topology"
          }
        ],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "create_topology_view",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_topology_view/read_topology",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_topology_view/read_topology.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "f0bea0375a74f7eaa7a0f5ce4424c38d0c66b7fce0bae9556a724589bfad619b",
      "signal_patterns": [],
      "skill_id": "cpu_topology_view",
      "source": {
        "path": "backend/skills/atomic/cpu_topology_view.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "8e7da2b8aae3dfcf076d784d1dde661efb18385e3c1d951ae6cd2ffa7978a8e6"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [
          "_cpu_topology"
        ],
        "setup_queries": [
          "cpu_topology_view/create_topology_view"
        ]
      },
      "step_id": "read_topology",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "cpu_topology_view"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_utilization_per_period/system_util",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_utilization_per_period/system_util.sql",
      "sha256": "31de4fd1e6cdae4972c7022d2d205c60990c818bbe871c3657d0a8a5f7e8bcc3",
      "signal_patterns": [],
      "skill_id": "cpu_utilization_per_period",
      "source": {
        "path": "backend/skills/atomic/cpu_utilization_per_period.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "9920c14a1dfb568ab235f8ad07dc05900335274cf3a7715383808227764b30a7"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.utilization.system"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "system_util",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "cpu_utilization_per_period"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_workload_attribution_in_range/workload_by_thread",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_workload_attribution_in_range/workload_by_thread.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "cffc7221b8fbbb46d9e710e012c6bd3b62b2a54efd08cdbc4e60ec058446c3ab",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "cpu_workload_attribution_in_range",
      "source": {
        "path": "backend/skills/atomic/cpu_workload_attribution_in_range.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "7e150bf0fccbde7798b1ea3fa0202056b1f528b993c25a86be0fa41fff44308b"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "intervals.intersect",
          "android.process_metadata"
        ],
        "drops": [],
        "required_tables": [
          "sched_slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "workload_by_thread",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/system_sched_spans.sql",
            "source_sha256": "ebcdcc6f476c4109051e817bcd107b1e45351faea14ff238ba76fb3f53b0b032"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/system_cpu_frequency_spans.sql",
            "source_sha256": "b874887b2a598182d29b088ea7b350d89687142dc07e8fb1c9dbc771c54b48b1"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/actor_class_labels.sql",
            "source_sha256": "b28f4189f24c03662c31a826cb3e854e0855e0d93f6f25b2dcf9b7dcef44287d"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "package",
          "process_name",
          "start_ts",
          "top_n"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "cpu_workload_attribution_in_range/workload_summary",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/cpu_workload_attribution_in_range/workload_summary.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "fc332bbd08dd15a04fe404b57e608ccbb966df66920009fda19e0da8678222cc",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "cpu_workload_attribution_in_range",
      "source": {
        "path": "backend/skills/atomic/cpu_workload_attribution_in_range.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "7e150bf0fccbde7798b1ea3fa0202056b1f528b993c25a86be0fa41fff44308b"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "intervals.intersect",
          "android.process_metadata"
        ],
        "drops": [],
        "required_tables": [
          "sched_slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "workload_summary",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/system_sched_spans.sql",
            "source_sha256": "ebcdcc6f476c4109051e817bcd107b1e45351faea14ff238ba76fb3f53b0b032"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/actor_class_labels.sql",
            "source_sha256": "b28f4189f24c03662c31a826cb3e854e0855e0d93f6f25b2dcf9b7dcef44287d"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "package",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "cpu_workload_attribution_in_range"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "counters",
          "slices"
        ]
      },
      "id": "device_state_snapshot/environment_snapshot",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/device_state_snapshot/environment_snapshot.sql",
      "sha256": "0e34baac5629f6f152321960edb4b290fb6355b0dd5ef798a8847d88d2d593eb",
      "signal_patterns": [
        "*BatteryLevel*",
        "*BatteryStatus*",
        "*MemAvailable*",
        "*MemFree*",
        "*ScreenState*",
        "*Temperature*",
        "*battery_level*",
        "*battery_status*",
        "*charging*",
        "*mem.*pressure*",
        "*psi*mem*",
        "*screen_state*",
        "*temp*",
        "*thermal_zone*"
      ],
      "skill_id": "device_state_snapshot",
      "source": {
        "path": "backend/skills/composite/device_state_snapshot.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "886bf69ae41b697f5c80cad4e1787cc5198233e15f65cb3c9cb3d382ca3b3655"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "counter",
          "counter_track"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "environment_snapshot",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "counters",
          "slices"
        ]
      },
      "id": "device_state_snapshot/idle_window_summary",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/device_state_snapshot/idle_window_summary.sql",
      "sha256": "0daf2e02907ca9f85d2f37de9cfe4e3c1050714a6ddda7a0cb07e189d91455b0",
      "signal_patterns": [
        "*Idle*",
        "*doze*",
        "*idle*",
        "*suspend*"
      ],
      "skill_id": "device_state_snapshot",
      "source": {
        "path": "backend/skills/composite/device_state_snapshot.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "886bf69ae41b697f5c80cad4e1787cc5198233e15f65cb3c9cb3d382ca3b3655"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "counter",
          "counter_track"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "idle_window_summary",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "device_state_snapshot"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "device_state_timeline/cpu_freq_transitions",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/device_state_timeline/cpu_freq_transitions.sql",
      "sha256": "b58b5249720c126f554a996641e21a5d29a1a7075bb173a12cd702db53a3fccc",
      "signal_patterns": [
        "cpufreq"
      ],
      "skill_id": "device_state_timeline",
      "source": {
        "path": "backend/skills/atomic/device_state_timeline.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "4bdcfcf7ad8209f5290e1f7a6e7ff4d7886529fa423c89e440374bc4111114d1"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "counter",
          "counter_track"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "cpu_freq_transitions",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "device_state_timeline/thermal_events",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/device_state_timeline/thermal_events.sql",
      "sha256": "d002914f16eb74880ce03fe66ba3c76f498df0e586e8341ec90a28b8df3c735e",
      "signal_patterns": [
        "*Temperature*",
        "*temp*",
        "*thermal_zone*",
        "*tsens*"
      ],
      "skill_id": "device_state_timeline",
      "source": {
        "path": "backend/skills/atomic/device_state_timeline.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "4bdcfcf7ad8209f5290e1f7a6e7ff4d7886529fa423c89e440374bc4111114d1"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "counter",
          "counter_track"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "thermal_events",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "device_state_timeline/memory_pressure_events",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/device_state_timeline/memory_pressure_events.sql",
      "sha256": "ec1f900df785d8b9a8f765873c2902550afac8c6fc3b171dbc51690386ce94a9",
      "signal_patterns": [
        "*MemAvailable*",
        "*MemFree*",
        "*lowmemkiller*",
        "*mem.*pressure*",
        "*psi*mem*"
      ],
      "skill_id": "device_state_timeline",
      "source": {
        "path": "backend/skills/atomic/device_state_timeline.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "4bdcfcf7ad8209f5290e1f7a6e7ff4d7886529fa423c89e440374bc4111114d1"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "counter",
          "counter_track"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "memory_pressure_events",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "device_state_timeline/gpu_freq_transitions",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/device_state_timeline/gpu_freq_transitions.sql",
      "sha256": "f8cbc3316c4d7d186e68e2ce26a4b35b31fbb3760ec201d6a6f68e055751b802",
      "signal_patterns": [
        "gpufreq"
      ],
      "skill_id": "device_state_timeline",
      "source": {
        "path": "backend/skills/atomic/device_state_timeline.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "4bdcfcf7ad8209f5290e1f7a6e7ff4d7886529fa423c89e440374bc4111114d1"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "counter",
          "counter_track"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gpu_freq_transitions",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/gpu_frequency_intervals.sql",
            "source_sha256": "2bd8dac125b274ab3a3966e9f43ed780d0eef389b2eb5c0ee60e82fbfb5d6cba"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "device_state_timeline"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "dmabuf_analysis/data_check",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/dmabuf_analysis/data_check.sql",
      "sha256": "ccc765cee0bdc7f35b54712c80b9055453effc418518e0dd68fb1019b54e560b",
      "signal_patterns": [],
      "skill_id": "dmabuf_analysis",
      "source": {
        "path": "backend/skills/composite/dmabuf_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "15c7918ef202638b9eb23a3c1e4d1b3f3ab1e091ae7c43784b1858386b89227d"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.dmabuf"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "data_check",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "dmabuf_analysis/dmabuf_overview",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/dmabuf_analysis/dmabuf_overview.sql",
      "sha256": "c2516721617883773c40ebe79f884ca578fb5f8eb6e1facc651b70442abea05d",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "dmabuf_analysis",
      "source": {
        "path": "backend/skills/composite/dmabuf_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "15c7918ef202638b9eb23a3c1e4d1b3f3ab1e091ae7c43784b1858386b89227d"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.dmabuf"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "dmabuf_overview",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "dmabuf_analysis/dmabuf_cumulative",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/dmabuf_analysis/dmabuf_cumulative.sql",
      "sha256": "e1c553504352623ecf2303d3da5fa052ac4d4cb89e84d7f96409f599dd2aed10",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "dmabuf_analysis",
      "source": {
        "path": "backend/skills/composite/dmabuf_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "15c7918ef202638b9eb23a3c1e4d1b3f3ab1e091ae7c43784b1858386b89227d"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.dmabuf"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "dmabuf_cumulative",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "dmabuf_analysis/large_buffer_allocs",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/dmabuf_analysis/large_buffer_allocs.sql",
      "sha256": "655c65d0f6f618ff920c08bff6499627b804f3386ae2b1322099274717bbcc05",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "dmabuf_analysis",
      "source": {
        "path": "backend/skills/composite/dmabuf_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "15c7918ef202638b9eb23a3c1e4d1b3f3ab1e091ae7c43784b1858386b89227d"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.dmabuf"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "large_buffer_allocs",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "min_size_mb",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "dmabuf_analysis/dmabuf_frequency",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/dmabuf_analysis/dmabuf_frequency.sql",
      "sha256": "007a4b10a29854b3260af6b8b6f6cf81113debb0256959a237a8b50a86a11e81",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "dmabuf_analysis",
      "source": {
        "path": "backend/skills/composite/dmabuf_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "15c7918ef202638b9eb23a3c1e4d1b3f3ab1e091ae7c43784b1858386b89227d"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.dmabuf"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "dmabuf_frequency",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "dmabuf_analysis/thread_alloc_stats",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/dmabuf_analysis/thread_alloc_stats.sql",
      "sha256": "8ab8c35c91c04e254c7074c44276915ddcf850c11ff9e141461c33ff7a99a80a",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "dmabuf_analysis",
      "source": {
        "path": "backend/skills/composite/dmabuf_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "15c7918ef202638b9eb23a3c1e4d1b3f3ab1e091ae7c43784b1858386b89227d"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.dmabuf"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "thread_alloc_stats",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "dmabuf_analysis/buffer_lifecycle",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/dmabuf_analysis/buffer_lifecycle.sql",
      "sha256": "ac2ec2e784acae3a928840a8c3c02b1017f77294313c6be9e29165c71c559584",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "dmabuf_analysis",
      "source": {
        "path": "backend/skills/composite/dmabuf_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "15c7918ef202638b9eb23a3c1e4d1b3f3ab1e091ae7c43784b1858386b89227d"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.dmabuf"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "buffer_lifecycle",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "dmabuf_analysis/root_cause_classification",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/dmabuf_analysis/root_cause_classification.sql",
      "sha256": "dc4dde4e7466e280e3e873726a098f351985329c63dcbef2cc72d6a64d50eacc",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "dmabuf_analysis",
      "source": {
        "path": "backend/skills/composite/dmabuf_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "15c7918ef202638b9eb23a3c1e4d1b3f3ab1e091ae7c43784b1858386b89227d"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.dmabuf"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root_cause_classification",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "dmabuf_analysis"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "fence_wait_decomposition/acquire_fence_wait",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/fence_wait_decomposition/acquire_fence_wait.sql",
      "sha256": "aaecf0a0b7f0484ca2324e4ba983884f2187f7af7515a239cdbab234674c5bc5",
      "signal_patterns": [
        "*acquireBuffer*",
        "*latchBuffer*",
        "surfaceflinger"
      ],
      "skill_id": "fence_wait_decomposition",
      "source": {
        "path": "backend/skills/atomic/fence_wait_decomposition.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "75f359793eed661eb1be28d6514d7eca7a9defec4fa11b309b3166f25d9ee94a"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "acquire_fence_wait",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "fence_wait_decomposition/present_fence_timing",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/fence_wait_decomposition/present_fence_timing.sql",
      "sha256": "ab29b8d99843c618447892c0f5c47b7feeb2a94af48d1c0d89d449c86e4c676b",
      "signal_patterns": [
        "*presentDisplay*",
        "surfaceflinger"
      ],
      "skill_id": "fence_wait_decomposition",
      "source": {
        "path": "backend/skills/atomic/fence_wait_decomposition.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "75f359793eed661eb1be28d6514d7eca7a9defec4fa11b309b3166f25d9ee94a"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "present_fence_timing",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "fence_wait_decomposition/release_fence_impact",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/fence_wait_decomposition/release_fence_impact.sql",
      "sha256": "514401a9a8fe6a74c69c246490b493cd40758df35256a8dfdd5778c9cef42192",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*dequeueBuffer*"
      ],
      "skill_id": "fence_wait_decomposition",
      "source": {
        "path": "backend/skills/atomic/fence_wait_decomposition.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "75f359793eed661eb1be28d6514d7eca7a9defec4fa11b309b3166f25d9ee94a"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "release_fence_impact",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "fence_wait_decomposition/fence_attribution_hint",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/fence_wait_decomposition/fence_attribution_hint.sql",
      "sha256": "ff63fa22aebc6823c1108e350bdeb089b7ba744a5522899b62b8680f990b5ace",
      "signal_patterns": [
        "*acquireBuffer*",
        "*dequeueBuffer*",
        "*latchBuffer*",
        "*presentDisplay*",
        "surfaceflinger"
      ],
      "skill_id": "fence_wait_decomposition",
      "source": {
        "path": "backend/skills/atomic/fence_wait_decomposition.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "75f359793eed661eb1be28d6514d7eca7a9defec4fa11b309b3166f25d9ee94a"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "fence_attribution_hint",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "fence_wait_decomposition"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices",
          "thread_states"
        ]
      },
      "id": "filesystem_module/io_overview",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/filesystem_module/io_overview.sql",
      "sha256": "2f43355b47d25411e8e7a796f1c8ab8ddcd3771ec35261805ab93c9025388ae6",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "filesystem_module",
      "source": {
        "path": "backend/skills/modules/kernel/filesystem_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "18dec147f2bfaecf6ae89f2942cc87828fb95e48502a1ff7633dd43fe54fa3d3"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process",
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "io_overview",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/file_io_slice_names.sql",
            "source_sha256": "c93482a31b7576ab8570803e1b6c9c68beaaed8a9a7eef690e385bb26ec443ed"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices",
          "thread_states"
        ]
      },
      "id": "filesystem_module/main_thread_io",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/filesystem_module/main_thread_io.sql",
      "sha256": "a5c5bfb985139f84ad790ebd1b68182679ee941a80af193b2045baf4f31eb632",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "filesystem_module",
      "source": {
        "path": "backend/skills/modules/kernel/filesystem_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "18dec147f2bfaecf6ae89f2942cc87828fb95e48502a1ff7633dd43fe54fa3d3"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process",
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "main_thread_io",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/file_io_slice_names.sql",
            "source_sha256": "c93482a31b7576ab8570803e1b6c9c68beaaed8a9a7eef690e385bb26ec443ed"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices",
          "thread_states"
        ]
      },
      "id": "filesystem_module/database_operations",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/filesystem_module/database_operations.sql",
      "sha256": "0585c1a673347649779befea8bc5f74d6c14486bd4c96839e160b93df633b574",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "filesystem_module",
      "source": {
        "path": "backend/skills/modules/kernel/filesystem_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "18dec147f2bfaecf6ae89f2942cc87828fb95e48502a1ff7633dd43fe54fa3d3"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process",
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "database_operations",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices",
          "thread_states"
        ]
      },
      "id": "filesystem_module/shared_prefs_operations",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/filesystem_module/shared_prefs_operations.sql",
      "sha256": "b4cbe249aa54549f73d564ac185ea70902ea8346e3c758c9d80d64e725b57b1a",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "filesystem_module",
      "source": {
        "path": "backend/skills/modules/kernel/filesystem_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "18dec147f2bfaecf6ae89f2942cc87828fb95e48502a1ff7633dd43fe54fa3d3"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process",
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "shared_prefs_operations",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices",
          "thread_states"
        ]
      },
      "id": "filesystem_module/io_wait_state",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/filesystem_module/io_wait_state.sql",
      "sha256": "81798c397aba1f1de3929dd0c10338eb166c9c3e0035a0517a4e6d6935cefa5a",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "filesystem_module",
      "source": {
        "path": "backend/skills/modules/kernel/filesystem_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "18dec147f2bfaecf6ae89f2942cc87828fb95e48502a1ff7633dd43fe54fa3d3"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process",
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "io_wait_state",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/io_blocked_function_families.sql",
            "source_sha256": "8d45506b0b20c30c432f555da5a21e293f3d290c55059f1cd3f508f77df72bb0"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices",
          "thread_states"
        ]
      },
      "id": "filesystem_module/slow_io_operations",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/filesystem_module/slow_io_operations.sql",
      "sha256": "1255470fa8878b2a89241366a04ccad710c8e7194504bad9fafa1d2e6a2e38dc",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "filesystem_module",
      "source": {
        "path": "backend/skills/modules/kernel/filesystem_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "18dec147f2bfaecf6ae89f2942cc87828fb95e48502a1ff7633dd43fe54fa3d3"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process",
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "slow_io_operations",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/file_io_slice_names.sql",
            "source_sha256": "c93482a31b7576ab8570803e1b6c9c68beaaed8a9a7eef690e385bb26ec443ed"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "filesystem_module"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "frame_timeline"
        ]
      },
      "id": "flutter_scrolling_analysis/flutter_frame_overview",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/flutter_scrolling_analysis/flutter_frame_overview.sql",
      "sha256": "761349e468bca9835062fb0720f5de215773bb90d77fcf8273991d5120e8c78f",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "DartWorker*",
        "VSYNC-sf",
        "[0-9]*.io",
        "[0-9]*.raster",
        "[0-9]*.ui"
      ],
      "skill_id": "flutter_scrolling_analysis",
      "source": {
        "path": "backend/skills/composite/flutter_scrolling_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1f345fc088535bbce0d3edac849ed979ebf199178b142f2f24cc08d716a5a5f0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.timeline",
          "android.frames.jank_type"
        ],
        "drops": [],
        "required_tables": [
          "actual_frame_timeline_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "flutter_frame_overview",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/flutter_process_identity.sql",
            "source_sha256": "64bea70d0bef4cf8162cf6b4bde15949d6dd59739ca25ff30bd8ed970396a95c"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts",
          "vsync_period_ns"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "frame_timeline"
        ]
      },
      "id": "flutter_scrolling_analysis/flutter_thread_analysis",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/flutter_scrolling_analysis/flutter_thread_analysis.sql",
      "sha256": "4e89fbc61ad55eaac7619ba2488a438e574a93ccd598efa755292c1def0c248b",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*1.io*",
        "*1.raster*",
        "*1.ui*",
        "*DrawFrame*",
        "*SurfaceTexture*",
        "*queueBuffer*",
        "*updateTexImage*",
        "DartWorker*",
        "RenderThread",
        "[0-9]*.io",
        "[0-9]*.raster",
        "[0-9]*.ui"
      ],
      "skill_id": "flutter_scrolling_analysis",
      "source": {
        "path": "backend/skills/composite/flutter_scrolling_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1f345fc088535bbce0d3edac849ed979ebf199178b142f2f24cc08d716a5a5f0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.timeline",
          "android.frames.jank_type"
        ],
        "drops": [],
        "required_tables": [
          "actual_frame_timeline_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "flutter_thread_analysis",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/flutter_process_identity.sql",
            "source_sha256": "64bea70d0bef4cf8162cf6b4bde15949d6dd59739ca25ff30bd8ed970396a95c"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts",
          "vsync_period_ns"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "frame_timeline"
        ]
      },
      "id": "flutter_scrolling_analysis/flutter_consumer_jank",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/flutter_scrolling_analysis/flutter_consumer_jank.sql",
      "sha256": "a165cfc0cc872ebe9befbbfd69445f3768f9cad01d36c229940d9899a4da9c63",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "DartWorker*",
        "VSYNC-sf",
        "[0-9]*.io",
        "[0-9]*.raster",
        "[0-9]*.ui"
      ],
      "skill_id": "flutter_scrolling_analysis",
      "source": {
        "path": "backend/skills/composite/flutter_scrolling_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1f345fc088535bbce0d3edac849ed979ebf199178b142f2f24cc08d716a5a5f0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.timeline",
          "android.frames.jank_type"
        ],
        "drops": [],
        "required_tables": [
          "actual_frame_timeline_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "flutter_consumer_jank",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/flutter_process_identity.sql",
            "source_sha256": "64bea70d0bef4cf8162cf6b4bde15949d6dd59739ca25ff30bd8ed970396a95c"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "frame_timeline"
        ]
      },
      "id": "flutter_scrolling_analysis/flutter_jank_frames",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/flutter_scrolling_analysis/flutter_jank_frames.sql",
      "sha256": "6ad5a864f06fa18070779d2375c5c52acef8c9de2d84052b773451de44fb6de9",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "DartWorker*",
        "[0-9]*.io",
        "[0-9]*.raster",
        "[0-9]*.ui"
      ],
      "skill_id": "flutter_scrolling_analysis",
      "source": {
        "path": "backend/skills/composite/flutter_scrolling_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1f345fc088535bbce0d3edac849ed979ebf199178b142f2f24cc08d716a5a5f0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.timeline",
          "android.frames.jank_type"
        ],
        "drops": [],
        "required_tables": [
          "actual_frame_timeline_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "flutter_jank_frames",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/flutter_process_identity.sql",
            "source_sha256": "64bea70d0bef4cf8162cf6b4bde15949d6dd59739ca25ff30bd8ed970396a95c"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts",
          "vsync_period_ns"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "frame_timeline"
        ]
      },
      "id": "flutter_scrolling_analysis/flutter_ui_thread_long_slices",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/flutter_scrolling_analysis/flutter_ui_thread_long_slices.sql",
      "sha256": "21e0f3f6c5a2cbae306a9646e07c08980e935123f596203204649d073ad476c8",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "%BeginFrame%",
        "%Build%",
        "%Layout%",
        "%Paint%",
        "%Semantics%",
        "*1.ui*",
        "DartWorker*",
        "[0-9]*.io",
        "[0-9]*.raster",
        "[0-9]*.ui"
      ],
      "skill_id": "flutter_scrolling_analysis",
      "source": {
        "path": "backend/skills/composite/flutter_scrolling_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1f345fc088535bbce0d3edac849ed979ebf199178b142f2f24cc08d716a5a5f0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.timeline",
          "android.frames.jank_type"
        ],
        "drops": [],
        "required_tables": [
          "actual_frame_timeline_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "flutter_ui_thread_long_slices",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/flutter_process_identity.sql",
            "source_sha256": "64bea70d0bef4cf8162cf6b4bde15949d6dd59739ca25ff30bd8ed970396a95c"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts",
          "vsync_period_ns"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "frame_timeline"
        ]
      },
      "id": "flutter_scrolling_analysis/flutter_raster_thread_long_slices",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/flutter_scrolling_analysis/flutter_raster_thread_long_slices.sql",
      "sha256": "7b5fb2b915e417abc230860dadc4ac4f05f29577e2f7ebbb16132778aac7dae1",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "%Compositor%",
        "%DrawToSurface%",
        "%EntityPass%",
        "%SkGpu%",
        "*1.raster*",
        "DartWorker*",
        "[0-9]*.io",
        "[0-9]*.raster",
        "[0-9]*.ui"
      ],
      "skill_id": "flutter_scrolling_analysis",
      "source": {
        "path": "backend/skills/composite/flutter_scrolling_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1f345fc088535bbce0d3edac849ed979ebf199178b142f2f24cc08d716a5a5f0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.timeline",
          "android.frames.jank_type"
        ],
        "drops": [],
        "required_tables": [
          "actual_frame_timeline_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "flutter_raster_thread_long_slices",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/flutter_process_identity.sql",
            "source_sha256": "64bea70d0bef4cf8162cf6b4bde15949d6dd59739ca25ff30bd8ed970396a95c"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts",
          "vsync_period_ns"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "flutter_scrolling_analysis"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "fpsgo_analysis/root",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/fpsgo_analysis/query.sql",
      "sha256": "130d40e4c922b490085864287c483d26791dd2e8f43eaf5c6e1e2bcf9e4d99ae",
      "signal_patterns": [
        "*FBT*",
        "*FSTB*",
        "*GED*",
        "*PerfService*",
        "*PowerHal*",
        "*boost*",
        "*fbt*",
        "*fpsgo*",
        "*fstb*",
        "*ged*",
        "*perf_idx*",
        "*rescue*",
        "*sched_boost*"
      ],
      "skill_id": "fpsgo_analysis",
      "source": {
        "path": "backend/skills/atomic/fpsgo_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "6ee6815848f62092599d709a15c857835fb298f96733192f8fc113c03acb42c3"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "fpsgo_analysis"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "frame_blocking_calls/root",
      "identity": {
        "aliases": [
          "process_name",
          "package"
        ],
        "minConfidence": 50,
        "policy": "required",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/frame_blocking_calls/query.sql",
      "sha256": "4c1c54b8cfd351c100829a86bda66f034b76a9a9f1464d1e971fd60991cfcf43",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*",
        "*Binder*",
        "*RenderThread*",
        "Binder:*",
        "RenderThread"
      ],
      "skill_id": "frame_blocking_calls",
      "source": {
        "path": "backend/skills/atomic/frame_blocking_calls.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "f50aec9da16055b40141764cc3668c04f17cc70cceddcf65c2cff8c9ae89a062"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.timeline",
          "android.critical_blocking_calls"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "frame_blocking_calls"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "frame_overrun_summary/overrun_frames",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/frame_overrun_summary/overrun_frames.sql",
      "sha256": "16ce9ea249888a28f735c2a7966d730002e877a1eb4e0ef612e61fcffa9b9674",
      "signal_patterns": [],
      "skill_id": "frame_overrun_summary",
      "source": {
        "path": "backend/skills/atomic/frame_overrun_summary.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "8d3f12c4ef5cd70e43445492df11219fc663818ce30eee71c44713c49ddec600"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.per_frame_metrics"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "overrun_frames",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "frame_overrun_summary"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "frame_timeline"
        ]
      },
      "id": "frame_pipeline_variance/root",
      "identity": {
        "aliases": [
          "package",
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/frame_pipeline_variance/query.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "01d0afbb7a44eacec8e0bf62f978f94a445bf0b9bdf8fb3c4c30d8959118e0eb",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "frame_pipeline_variance",
      "source": {
        "path": "backend/skills/atomic/frame_pipeline_variance.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "758727e5e7fe862de5324469e2a8006fa72f121bba6818661575c1f97dfbd823"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [
          "actual_frame_timeline_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts",
          "transition_threshold_ms"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "frame_pipeline_variance"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "frame_timeline",
          "slices"
        ]
      },
      "id": "frame_production_gap/gap_summary",
      "identity": {
        "aliases": [
          "process_name",
          "package"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/frame_production_gap/gap_summary.sql",
      "process_scope": {
        "binding": "native_upid",
        "role": "target"
      },
      "sha256": "55b185b9ffc44270e3052ac9d3410ac5df8a4734789f6b484782fcfd911494dc",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*",
        "Choreographer#doFrame%",
        "DrawFrame%",
        "RenderThread",
        "VSYNC-sf",
        "draw:%"
      ],
      "skill_id": "frame_production_gap",
      "source": {
        "path": "backend/skills/atomic/frame_production_gap.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "221c153dbac8c5a1a4efd28a5c917e2ab50b05b1f9d7f87eab25292fd01ddff0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "actual_frame_timeline_slice",
          "slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gap_summary",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "min_gap_vsync",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "frame_timeline",
          "slices"
        ]
      },
      "id": "frame_production_gap/gap_list",
      "identity": {
        "aliases": [
          "process_name",
          "package"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/frame_production_gap/gap_list.sql",
      "process_scope": {
        "binding": "native_upid",
        "role": "target"
      },
      "sha256": "8f8b88a9fe5119f0a0c6cedfa96b879bd35a09f8bb1d7cf43fb995bfb4d91837",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*",
        "Choreographer#doFrame%",
        "DrawFrame%",
        "RenderThread",
        "VSYNC-sf",
        "draw:%"
      ],
      "skill_id": "frame_production_gap",
      "source": {
        "path": "backend/skills/atomic/frame_production_gap.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "221c153dbac8c5a1a4efd28a5c917e2ab50b05b1f9d7f87eab25292fd01ddff0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "actual_frame_timeline_slice",
          "slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gap_list",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "min_gap_vsync",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "frame_production_gap"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "frame_ui_time_breakdown/ui_time",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/frame_ui_time_breakdown/ui_time.sql",
      "sha256": "e405b172985cc0e92980ae6fe60d4e8f1e188b2f4f2c093927a0ef8c563d96f7",
      "signal_patterns": [],
      "skill_id": "frame_ui_time_breakdown",
      "source": {
        "path": "backend/skills/atomic/frame_ui_time_breakdown.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "e954401abb0cdd3049a98ff540b0dcb21f44e7008292d852ac5fdc4426d59fcd"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.per_frame_metrics"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "ui_time",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "frame_ui_time_breakdown"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "futex_wait_distribution/root",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/futex_wait_distribution/query.sql",
      "sha256": "3b124801e7c230528bc9650898e1c23d1894b8f95d3ce292da8a496c0a2b649c",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "futex_wait_distribution",
      "source": {
        "path": "backend/skills/atomic/futex_wait_distribution.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "b4995afc55c08909120af15f468a3cfe33d21ec3543ae7509296c2f7dec683fd"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "futex_wait_distribution"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "frame_timeline"
        ]
      },
      "id": "game_fps_analysis/detect_target_fps",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/game_fps_analysis/detect_target_fps.sql",
      "sha256": "a9acf3087cc3f7f4b8dc9ef548b2ab41d4f03afea26072489cad5d596c83ab3d",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "game_fps_analysis",
      "source": {
        "path": "backend/skills/atomic/game_fps_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "afe29e2e27d3fbd6899c8b09c61c286650fe26e2f3f9585158f7f3d7818a7966"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [
          "actual_frame_timeline_slice",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "detect_target_fps",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "frame_timeline"
        ]
      },
      "id": "game_fps_analysis/frame_interval_stats",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/game_fps_analysis/frame_interval_stats.sql",
      "sha256": "67bd2f7316ce0d1d566419266812eb256dead87046f73f3c8ba4395ee95b3429",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "game_fps_analysis",
      "source": {
        "path": "backend/skills/atomic/game_fps_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "afe29e2e27d3fbd6899c8b09c61c286650fe26e2f3f9585158f7f3d7818a7966"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [
          "actual_frame_timeline_slice",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "frame_interval_stats",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "frame_timeline"
        ]
      },
      "id": "game_fps_analysis/jank_detection",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/game_fps_analysis/jank_detection.sql",
      "sha256": "fac041d3c83b64792d82bd92d90f376eb79bbb14172318186a4e8610d3ce8eee",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "game_fps_analysis",
      "source": {
        "path": "backend/skills/atomic/game_fps_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "afe29e2e27d3fbd6899c8b09c61c286650fe26e2f3f9585158f7f3d7818a7966"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [
          "actual_frame_timeline_slice",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "jank_detection",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts",
          "target_fps"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "game_fps_analysis"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "game_main_loop_jank/engine_loop_summary",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/game_main_loop_jank/engine_loop_summary.sql",
      "sha256": "94c4b78c8b355632bddc9660e3d7ae7152f7a89898ee42502b05959194d18239",
      "signal_patterns": [
        "*Camera.Render*",
        "*Cocos*",
        "*Director::mainLoop*",
        "*FrameGameThread*",
        "*GLThread*",
        "*GameThread*",
        "*Gfx.WaitForPresent*",
        "*Main::iteration*",
        "*PlayerLoop*",
        "*RHIThread*",
        "*RenderingThread*",
        "*Tick*",
        "*Unity*",
        "*UnityGfx*",
        "*Unreal*",
        "*Update*",
        "*WaitForPresent*",
        "*cocos2d*",
        "*idle_process*",
        "*physics_process*"
      ],
      "skill_id": "game_main_loop_jank",
      "source": {
        "path": "backend/skills/atomic/game_main_loop_jank.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "8e8fd62e11d703c67848024b1e5c80932cb4722011d4c83a6dbaa99802082f55"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "slices.with_context"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "thread_track",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "engine_loop_summary",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "package",
          "process_name",
          "start_ts",
          "target_frame_ms"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "game_main_loop_jank/slow_engine_slices",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/game_main_loop_jank/slow_engine_slices.sql",
      "sha256": "b8a5016b9c6bc01f271eb2154da0b74430891976ea2db9d1fe2fd9d93447e02c",
      "signal_patterns": [
        "*Camera.Render*",
        "*Cocos*",
        "*Director::mainLoop*",
        "*FrameGameThread*",
        "*GLThread*",
        "*GameThread*",
        "*Gfx.WaitForPresent*",
        "*Main::iteration*",
        "*PlayerLoop*",
        "*RHIThread*",
        "*RenderingThread*",
        "*Tick*",
        "*Unity*",
        "*UnityGfx*",
        "*Unreal*",
        "*Update*",
        "*WaitForPresent*",
        "*cocos2d*",
        "*idle_process*",
        "*physics_process*"
      ],
      "skill_id": "game_main_loop_jank",
      "source": {
        "path": "backend/skills/atomic/game_main_loop_jank.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "8e8fd62e11d703c67848024b1e5c80932cb4722011d4c83a6dbaa99802082f55"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "slices.with_context"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "thread_track",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "slow_engine_slices",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "package",
          "process_name",
          "start_ts",
          "target_frame_ms"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "game_main_loop_jank"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "gc_analysis/data_check",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gc_analysis/data_check.sql",
      "sha256": "62a0eeb0ddead82a90403f3889f2fec5e9b875d7eb818528f1e07122974980b9",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "gc_analysis",
      "source": {
        "path": "backend/skills/composite/gc_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "47cc9fb68d5a1829532f3fd9a415485a4c530444763c02c8273cf74db93c3845"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.garbage_collection"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "data_check",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "min_gc_dur_ms",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "gc_analysis/gc_overview",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gc_analysis/gc_overview.sql",
      "sha256": "d4130cfc86c02e2ebdcd3a002e496d4f9955bc19fddc15d41272fbd413d1cc06",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "gc_analysis",
      "source": {
        "path": "backend/skills/composite/gc_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "47cc9fb68d5a1829532f3fd9a415485a4c530444763c02c8273cf74db93c3845"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.garbage_collection"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gc_overview",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "min_gc_dur_ms",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "gc_analysis/gc_time_breakdown",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gc_analysis/gc_time_breakdown.sql",
      "sha256": "8f3231f753294b5c7750efdae00bff8501731a5af0d722211f16e27adc2896ce",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "gc_analysis",
      "source": {
        "path": "backend/skills/composite/gc_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "47cc9fb68d5a1829532f3fd9a415485a4c530444763c02c8273cf74db93c3845"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.garbage_collection"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gc_time_breakdown",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "gc_analysis/long_gc_events",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gc_analysis/long_gc_events.sql",
      "sha256": "70f063aca69bcf7a81765917dcab1873f65b90d3f6ab4b3b9dba8137de674533",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "gc_analysis",
      "source": {
        "path": "backend/skills/composite/gc_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "47cc9fb68d5a1829532f3fd9a415485a4c530444763c02c8273cf74db93c3845"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.garbage_collection"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "long_gc_events",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "min_gc_dur_ms",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "gc_analysis/gc_frame_impact",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gc_analysis/gc_frame_impact.sql",
      "sha256": "ace0c025581df610cd3df73ee254b20c71859b50343ef68d718eb9fb9bc09d3f",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "gc_analysis",
      "source": {
        "path": "backend/skills/composite/gc_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "47cc9fb68d5a1829532f3fd9a415485a4c530444763c02c8273cf74db93c3845"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.garbage_collection"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gc_frame_impact",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "gc_analysis/process_gc_stats",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gc_analysis/process_gc_stats.sql",
      "sha256": "f222fb970cf80eee7322ad32d86e5b93d78bf96802e2e8898db147496d36ce87",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "gc_analysis",
      "source": {
        "path": "backend/skills/composite/gc_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "47cc9fb68d5a1829532f3fd9a415485a4c530444763c02c8273cf74db93c3845"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.garbage_collection"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "process_gc_stats",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "gc_analysis/gc_frequency",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gc_analysis/gc_frequency.sql",
      "sha256": "cc66206961b615e2ae1eb772e5d8653cd900f8de109fc340c799389121f4fd25",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "gc_analysis",
      "source": {
        "path": "backend/skills/composite/gc_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "47cc9fb68d5a1829532f3fd9a415485a4c530444763c02c8273cf74db93c3845"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.garbage_collection"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gc_frequency",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "gc_analysis/root_cause_classification",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gc_analysis/root_cause_classification.sql",
      "sha256": "9921ba47be6905cb4586eda1d6d2c1248e8b765ef33c5eb902427b787eb8a08b",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "gc_analysis",
      "source": {
        "path": "backend/skills/composite/gc_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "47cc9fb68d5a1829532f3fd9a415485a4c530444763c02c8273cf74db93c3845"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.garbage_collection"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root_cause_classification",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "gc_analysis"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "gc_events_in_range/root",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gc_events_in_range/query.sql",
      "sha256": "b971dd8018489e622da929b5739bbd46e628b405beea6fa2e962436a97dd430c",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "gc_events_in_range",
      "source": {
        "path": "backend/skills/atomic/gc_events_in_range.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "e5cc8038e2b2ecb4fc7bed20131e40311fae60ff21f1e9ebb2dc40b418813409"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.garbage_collection"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "gc_events_in_range"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices",
          "thread_states"
        ]
      },
      "id": "global_trace_sanity_check/trace_window",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/global_trace_sanity_check/trace_window.sql",
      "sha256": "c0ac87542f46d4a3131bc2832d26572f57aa97b46ebebd82e510e37911a097b1",
      "signal_patterns": [],
      "skill_id": "global_trace_sanity_check",
      "source": {
        "path": "backend/skills/composite/global_trace_sanity_check.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1adb4b390eb80646b03d2994e975e118a1077859bf5dd960f70edeb33b0084e0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "sched.thread_level_parallelism"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "thread_state",
          "sched_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "trace_window",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "max_rows",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices",
          "thread_states"
        ]
      },
      "id": "global_trace_sanity_check/trace_diagnostics",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/global_trace_sanity_check/trace_diagnostics.sql",
      "sha256": "08012a7b12f2b4ed28eb4c151ec4b7a4c04328399727996e7aa2eb03ec1123a7",
      "signal_patterns": [],
      "skill_id": "global_trace_sanity_check",
      "source": {
        "path": "backend/skills/composite/global_trace_sanity_check.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1adb4b390eb80646b03d2994e975e118a1077859bf5dd960f70edeb33b0084e0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "sched.thread_level_parallelism"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "thread_state",
          "sched_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "trace_diagnostics",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "max_rows"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices",
          "thread_states"
        ]
      },
      "id": "global_trace_sanity_check/data_loss_stats",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/global_trace_sanity_check/data_loss_stats.sql",
      "sha256": "e4a904794e58e7edb3b86c8f7fab8c9f80e7a3638109c5da733506f0e2b9a2c0",
      "signal_patterns": [],
      "skill_id": "global_trace_sanity_check",
      "source": {
        "path": "backend/skills/composite/global_trace_sanity_check.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1adb4b390eb80646b03d2994e975e118a1077859bf5dd960f70edeb33b0084e0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "sched.thread_level_parallelism"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "thread_state",
          "sched_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "data_loss_stats",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "max_rows"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices",
          "thread_states"
        ]
      },
      "id": "global_trace_sanity_check/top_d_state_threads",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/global_trace_sanity_check/top_d_state_threads.sql",
      "sha256": "8ebb4365ec5ccdff0a539eacc6e402fec031f95bd8521c277da0e68fa54f5455",
      "signal_patterns": [],
      "skill_id": "global_trace_sanity_check",
      "source": {
        "path": "backend/skills/composite/global_trace_sanity_check.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1adb4b390eb80646b03d2994e975e118a1077859bf5dd960f70edeb33b0084e0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "sched.thread_level_parallelism"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "thread_state",
          "sched_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "top_d_state_threads",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "max_rows",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices",
          "thread_states"
        ]
      },
      "id": "global_trace_sanity_check/top_runnable_waits",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/global_trace_sanity_check/top_runnable_waits.sql",
      "sha256": "ab89f3672ed016a4a9512e535cb8b8e448ed2e371a3853e2744952f8164a3aa6",
      "signal_patterns": [],
      "skill_id": "global_trace_sanity_check",
      "source": {
        "path": "backend/skills/composite/global_trace_sanity_check.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1adb4b390eb80646b03d2994e975e118a1077859bf5dd960f70edeb33b0084e0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "sched.thread_level_parallelism"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "thread_state",
          "sched_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "top_runnable_waits",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "max_rows",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices",
          "thread_states"
        ]
      },
      "id": "global_trace_sanity_check/runqueue_pressure",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/global_trace_sanity_check/runqueue_pressure.sql",
      "sha256": "372d720c22fa439dfa0f553bb29e2f890bf595412ce50b525ba3603143c1029c",
      "signal_patterns": [],
      "skill_id": "global_trace_sanity_check",
      "source": {
        "path": "backend/skills/composite/global_trace_sanity_check.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1adb4b390eb80646b03d2994e975e118a1077859bf5dd960f70edeb33b0084e0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "sched.thread_level_parallelism"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "thread_state",
          "sched_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "runqueue_pressure",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices",
          "thread_states"
        ]
      },
      "id": "global_trace_sanity_check/top_cpu_processes",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/global_trace_sanity_check/top_cpu_processes.sql",
      "sha256": "e0ba2ecad142b742a0ef352e4bad743294793e49666ddebb69bfed243da089a1",
      "signal_patterns": [],
      "skill_id": "global_trace_sanity_check",
      "source": {
        "path": "backend/skills/composite/global_trace_sanity_check.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1adb4b390eb80646b03d2994e975e118a1077859bf5dd960f70edeb33b0084e0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "sched.thread_level_parallelism"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "thread_state",
          "sched_slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "top_cpu_processes",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "max_rows",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "global_trace_sanity_check"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "gl_standalone_swap_jank/swap_interval_summary",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gl_standalone_swap_jank/swap_interval_summary.sql",
      "sha256": "97f1ff4b2906a787e1d2fb1ed80e123a7f7f761da5a30d6d65d382d759805513",
      "signal_patterns": [
        "*ANativeWindow_queueBuffer*",
        "*SwapBuffers*",
        "*eglSwapBuffers*",
        "*vkQueuePresent*"
      ],
      "skill_id": "gl_standalone_swap_jank",
      "source": {
        "path": "backend/skills/atomic/gl_standalone_swap_jank.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "fb80d72459a0595df8c59974682e5b59c2b3d5afd3ec9ce2c832fe9180d9d6af"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "slices.with_context"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "thread_track",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "swap_interval_summary",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "package",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "gl_standalone_swap_jank/slow_swap_events",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gl_standalone_swap_jank/slow_swap_events.sql",
      "sha256": "dec872a1f43386842f72995814b843ea45e19e651729f5d52b9de0cb4ca73383",
      "signal_patterns": [
        "*ANativeWindow_queueBuffer*",
        "*SwapBuffers*",
        "*eglSwapBuffers*",
        "*vkQueuePresent*"
      ],
      "skill_id": "gl_standalone_swap_jank",
      "source": {
        "path": "backend/skills/atomic/gl_standalone_swap_jank.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "fb80d72459a0595df8c59974682e5b59c2b3d5afd3ec9ce2c832fe9180d9d6af"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "slices.with_context"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "thread_track",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "slow_swap_events",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "package",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "gl_standalone_swap_jank"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "gpu_analysis/data_check",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_analysis/data_check.sql",
      "sha256": "0f94016ccc01da20724083065a36ef6f9d2bbc8120e9168b6536e9c31002a282",
      "signal_patterns": [
        "actual_frame_timeline_slice",
        "android_gpu_memory_per_process",
        "gpufreq"
      ],
      "skill_id": "gpu_analysis",
      "source": {
        "path": "backend/skills/composite/gpu_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "ccca4067c8ee136de6c5a431984bc78be6e76efd3e44164776f7513e754a9c90"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.gpu.memory",
          "intervals.intersect"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "data_check",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/gpu_frequency_intervals.sql",
            "source_sha256": "2bd8dac125b274ab3a3966e9f43ed780d0eef389b2eb5c0ee60e82fbfb5d6cba"
          }
        ],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "gpu_analysis/gpu_freq_overview",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_analysis/gpu_freq_overview.sql",
      "sha256": "850b9dcde8e32ce8a5d5790ec649e7febe5b8b16fe5779e6eb49dafb70e2b7cb",
      "signal_patterns": [
        "gpufreq"
      ],
      "skill_id": "gpu_analysis",
      "source": {
        "path": "backend/skills/composite/gpu_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "ccca4067c8ee136de6c5a431984bc78be6e76efd3e44164776f7513e754a9c90"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.gpu.memory",
          "intervals.intersect"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gpu_freq_overview",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/gpu_frequency_intervals.sql",
            "source_sha256": "2bd8dac125b274ab3a3966e9f43ed780d0eef389b2eb5c0ee60e82fbfb5d6cba"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/gpu_frequency_window.sql",
            "source_sha256": "f615d9d238a1c9aa1382d69f35e6adc7cb087cfefb0aad8cc117d774a1f6b17f"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/gpu_frequency_summary.sql",
            "source_sha256": "3e0a701cdd5e39f4b248ef4137a0928476716dbf4b74824cb29a40847d75387b"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "high_freq_threshold_pct",
          "low_freq_threshold_pct",
          "mid_freq_threshold_pct",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "gpu_analysis/gpu_memory_overview",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_analysis/gpu_memory_overview.sql",
      "sha256": "e94d260092d7a229a0b019eb6f71a625ae95918c8485c1efbd57a73640997b63",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "gpu_analysis",
      "source": {
        "path": "backend/skills/composite/gpu_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "ccca4067c8ee136de6c5a431984bc78be6e76efd3e44164776f7513e754a9c90"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.gpu.memory",
          "intervals.intersect"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gpu_memory_overview",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "gpu_analysis/gpu_freq_distribution",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_analysis/gpu_freq_distribution.sql",
      "sha256": "429207c5790b8c28b68c8132a0d0501190751c268fbdd35bf84b60ece9c7be7b",
      "signal_patterns": [
        "gpufreq"
      ],
      "skill_id": "gpu_analysis",
      "source": {
        "path": "backend/skills/composite/gpu_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "ccca4067c8ee136de6c5a431984bc78be6e76efd3e44164776f7513e754a9c90"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.gpu.memory",
          "intervals.intersect"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gpu_freq_distribution",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/gpu_frequency_intervals.sql",
            "source_sha256": "2bd8dac125b274ab3a3966e9f43ed780d0eef389b2eb5c0ee60e82fbfb5d6cba"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/gpu_frequency_window.sql",
            "source_sha256": "f615d9d238a1c9aa1382d69f35e6adc7cb087cfefb0aad8cc117d774a1f6b17f"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/gpu_frequency_summary.sql",
            "source_sha256": "3e0a701cdd5e39f4b248ef4137a0928476716dbf4b74824cb29a40847d75387b"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "gpu_analysis/gpu_frame_correlation",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_analysis/gpu_frame_correlation.sql",
      "sha256": "5767f47183504b7c66761c00621e84755108d211993e1fd979a1e90d5789f0ee",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "gpufreq"
      ],
      "skill_id": "gpu_analysis",
      "source": {
        "path": "backend/skills/composite/gpu_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "ccca4067c8ee136de6c5a431984bc78be6e76efd3e44164776f7513e754a9c90"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.gpu.memory",
          "intervals.intersect"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gpu_frame_correlation",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/gpu_frequency_intervals.sql",
            "source_sha256": "2bd8dac125b274ab3a3966e9f43ed780d0eef389b2eb5c0ee60e82fbfb5d6cba"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "gpu_analysis/gpu_high_load_periods",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_analysis/gpu_high_load_periods.sql",
      "sha256": "941f6f5b16bdadc1f655ddcbc4fe9c42a5bb4a19e7b93dd476850dd9c7e540b7",
      "signal_patterns": [
        "gpufreq"
      ],
      "skill_id": "gpu_analysis",
      "source": {
        "path": "backend/skills/composite/gpu_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "ccca4067c8ee136de6c5a431984bc78be6e76efd3e44164776f7513e754a9c90"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.gpu.memory",
          "intervals.intersect"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gpu_high_load_periods",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/gpu_frequency_intervals.sql",
            "source_sha256": "2bd8dac125b274ab3a3966e9f43ed780d0eef389b2eb5c0ee60e82fbfb5d6cba"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/gpu_frequency_window.sql",
            "source_sha256": "f615d9d238a1c9aa1382d69f35e6adc7cb087cfefb0aad8cc117d774a1f6b17f"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/gpu_frequency_summary.sql",
            "source_sha256": "3e0a701cdd5e39f4b248ef4137a0928476716dbf4b74824cb29a40847d75387b"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "high_load_min_dur_ns",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "gpu_analysis/root_cause_classification",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_analysis/root_cause_classification.sql",
      "sha256": "a9b96e00b0ccd6f1230992f057d861fe09f1ed2028bfba5bcdaa294409b4098d",
      "signal_patterns": [
        "gpufreq"
      ],
      "skill_id": "gpu_analysis",
      "source": {
        "path": "backend/skills/composite/gpu_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "ccca4067c8ee136de6c5a431984bc78be6e76efd3e44164776f7513e754a9c90"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.gpu.memory",
          "intervals.intersect"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root_cause_classification",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/gpu_frequency_intervals.sql",
            "source_sha256": "2bd8dac125b274ab3a3966e9f43ed780d0eef389b2eb5c0ee60e82fbfb5d6cba"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/gpu_frequency_window.sql",
            "source_sha256": "f615d9d238a1c9aa1382d69f35e6adc7cb087cfefb0aad8cc117d774a1f6b17f"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/gpu_frequency_summary.sql",
            "source_sha256": "3e0a701cdd5e39f4b248ef4137a0928476716dbf4b74824cb29a40847d75387b"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "freq_drop_count_threshold",
          "freq_drop_ratio",
          "high_freq_threshold_pct",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "gpu_analysis/fallback_no_gpu_data",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_analysis/fallback_no_gpu_data.sql",
      "sha256": "4016600cf9edc133c736a5ef1f3d4790726c8795812e6e45103c5ef10d34c94b",
      "signal_patterns": [],
      "skill_id": "gpu_analysis",
      "source": {
        "path": "backend/skills/composite/gpu_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "ccca4067c8ee136de6c5a431984bc78be6e76efd3e44164776f7513e754a9c90"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.gpu.memory",
          "intervals.intersect"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "fallback_no_gpu_data",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "gpu_analysis"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "gpu"
        ]
      },
      "id": "gpu_compute_kernel_analysis/data_check",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_compute_kernel_analysis/data_check.sql",
      "sha256": "010e03fb4e6adf5207f024d9564326a955a3929ab9fa1366569c0014b87089f2",
      "signal_patterns": [],
      "skill_id": "gpu_compute_kernel_analysis",
      "source": {
        "path": "backend/skills/composite/gpu_compute_kernel_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "04ce0fdb105d89c591b8d24656540615492754eb847da9f8bec211de2a39e9df"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "prelude.after_eof.events"
        ],
        "drops": [],
        "required_tables": [
          "gpu_slice",
          "gpu_track"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "data_check",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts",
          "ugpu"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "gpu"
        ]
      },
      "id": "gpu_compute_kernel_analysis/kernel_summary",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_compute_kernel_analysis/kernel_summary.sql",
      "sha256": "1ba2f6ac0a2708ae288defe347f97f154ec968fa9c6c6aa598d0ab15fa5fbe2d",
      "signal_patterns": [],
      "skill_id": "gpu_compute_kernel_analysis",
      "source": {
        "path": "backend/skills/composite/gpu_compute_kernel_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "04ce0fdb105d89c591b8d24656540615492754eb847da9f8bec211de2a39e9df"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "prelude.after_eof.events"
        ],
        "drops": [],
        "required_tables": [
          "gpu_slice",
          "gpu_track"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "kernel_summary",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "max_rows",
          "start_ts",
          "ugpu"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "gpu"
        ]
      },
      "id": "gpu_compute_kernel_analysis/launch_configuration",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_compute_kernel_analysis/launch_configuration.sql",
      "sha256": "65301722804ae0b96743a7dd70b934804f27edcd2494550e1de9491f8e77687c",
      "signal_patterns": [],
      "skill_id": "gpu_compute_kernel_analysis",
      "source": {
        "path": "backend/skills/composite/gpu_compute_kernel_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "04ce0fdb105d89c591b8d24656540615492754eb847da9f8bec211de2a39e9df"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "prelude.after_eof.events"
        ],
        "drops": [],
        "required_tables": [
          "gpu_slice",
          "gpu_track"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "launch_configuration",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "max_rows",
          "start_ts",
          "ugpu"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "gpu"
        ]
      },
      "id": "gpu_compute_kernel_analysis/no_compute_contract",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_compute_kernel_analysis/no_compute_contract.sql",
      "sha256": "75a7177fdc518c625a0064f49ab93b353194ef654305c79c873b09e936a5fe0b",
      "signal_patterns": [],
      "skill_id": "gpu_compute_kernel_analysis",
      "source": {
        "path": "backend/skills/composite/gpu_compute_kernel_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "04ce0fdb105d89c591b8d24656540615492754eb847da9f8bec211de2a39e9df"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "prelude.after_eof.events"
        ],
        "drops": [],
        "required_tables": [
          "gpu_slice",
          "gpu_track"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "no_compute_contract",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "gpu"
        ]
      },
      "id": "gpu_compute_kernel_analysis/missing_launch_args_contract",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_compute_kernel_analysis/missing_launch_args_contract.sql",
      "sha256": "d944a88774f3677e938d449f786415e69945e890e7828163b9d60e0ff0727089",
      "signal_patterns": [],
      "skill_id": "gpu_compute_kernel_analysis",
      "source": {
        "path": "backend/skills/composite/gpu_compute_kernel_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "04ce0fdb105d89c591b8d24656540615492754eb847da9f8bec211de2a39e9df"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "prelude.after_eof.events"
        ],
        "drops": [],
        "required_tables": [
          "gpu_slice",
          "gpu_track"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "missing_launch_args_contract",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "gpu_compute_kernel_analysis"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "gpu_frequency_analysis/root",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_frequency_analysis/query.sql",
      "sha256": "3708d694d6dca02e6d7d7ef6afdc327b5258d2eb15243440e993853d6b8a74f8",
      "signal_patterns": [
        "gpufreq"
      ],
      "skill_id": "gpu_frequency_analysis",
      "source": {
        "path": "backend/skills/atomic/gpu_frequency_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1d59af695d05776443586c0844c80e4355558779825f9f6befb83acc2b8338d0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/gpu_frequency_intervals.sql",
            "source_sha256": "2bd8dac125b274ab3a3966e9f43ed780d0eef389b2eb5c0ee60e82fbfb5d6cba"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/gpu_frequency_window.sql",
            "source_sha256": "f615d9d238a1c9aa1382d69f35e6adc7cb087cfefb0aad8cc117d774a1f6b17f"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/gpu_frequency_summary.sql",
            "source_sha256": "3e0a701cdd5e39f4b248ef4137a0928476716dbf4b74824cb29a40847d75387b"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "gpu_frequency_analysis"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "gpu_freq_in_range/root",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_freq_in_range/query.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "a901f050bc3dc4bdeabe9af649dcc1d1f1ccd8de73cf325b9220353e6131511a",
      "signal_patterns": [
        "gpufreq"
      ],
      "skill_id": "gpu_freq_in_range",
      "source": {
        "path": "backend/skills/atomic/gpu_freq_in_range.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "d7a056a78bb004c44c0adf586f2b7196787ca1a028962541130e5731e76a7096"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/gpu_frequency_intervals.sql",
            "source_sha256": "2bd8dac125b274ab3a3966e9f43ed780d0eef389b2eb5c0ee60e82fbfb5d6cba"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/gpu_frequency_window.sql",
            "source_sha256": "f615d9d238a1c9aa1382d69f35e6adc7cb087cfefb0aad8cc117d774a1f6b17f"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/gpu_frequency_summary.sql",
            "source_sha256": "3e0a701cdd5e39f4b248ef4137a0928476716dbf4b74824cb29a40847d75387b"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "low_freq_threshold_pct",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "gpu_freq_in_range"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "gpu_metrics/gpu_frequency",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_metrics/gpu_frequency.sql",
      "sha256": "2f797fa708703cfa7017f6fa468cd7c7c858e195d484907c57819d5da81d7951",
      "signal_patterns": [
        "gpufreq"
      ],
      "skill_id": "gpu_metrics",
      "source": {
        "path": "backend/skills/atomic/gpu_metrics.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "80fe51882560c325dcd072ed62a0c07db6b43a2fdf215b072b366077ec1fbf51"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gpu_frequency",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/gpu_frequency_intervals.sql",
            "source_sha256": "2bd8dac125b274ab3a3966e9f43ed780d0eef389b2eb5c0ee60e82fbfb5d6cba"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/gpu_descriptor_frequency_tracks.sql",
            "source_sha256": "a8285ba30e2e409ecf900beee1c6cc99e6cf6feb540387e0ab0eadf59a784652"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "gpu_metrics/gpu_utilization",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_metrics/gpu_utilization.sql",
      "sha256": "02d3c0705af9bbaa6a2741e1c2a1260efda968066892b1d4c9461cafb207fca8",
      "signal_patterns": [
        "*Busy*",
        "*Util*",
        "*busy*",
        "*util*"
      ],
      "skill_id": "gpu_metrics",
      "source": {
        "path": "backend/skills/atomic/gpu_metrics.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "80fe51882560c325dcd072ed62a0c07db6b43a2fdf215b072b366077ec1fbf51"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gpu_utilization",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "gpu_metrics/gpu_render_time",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_metrics/gpu_render_time.sql",
      "sha256": "3072c745717064c4821c9692f5295a6eef7e2dcd2d55fa1f1c85863a26009a0d",
      "signal_patterns": [
        "*Draw*Call*",
        "*GPU*",
        "*Render*Pass*",
        "*Shader*",
        "*fence*signal*",
        "*gl*Draw*",
        "*gpu*",
        "*vkQueue*"
      ],
      "skill_id": "gpu_metrics",
      "source": {
        "path": "backend/skills/atomic/gpu_metrics.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "80fe51882560c325dcd072ed62a0c07db6b43a2fdf215b072b366077ec1fbf51"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gpu_render_time",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "gpu_metrics/gpu_fence_waits",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_metrics/gpu_fence_waits.sql",
      "sha256": "a8008e0066861046a6b244553d7a53e94102f7ab0c8aca816855546584a9f12e",
      "signal_patterns": [
        "*Fence*",
        "*GPU completion*",
        "*Waiting for GPU*",
        "*fence*",
        "VSYNC-sf"
      ],
      "skill_id": "gpu_metrics",
      "source": {
        "path": "backend/skills/atomic/gpu_metrics.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "80fe51882560c325dcd072ed62a0c07db6b43a2fdf215b072b366077ec1fbf51"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gpu_fence_waits",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "gpu_metrics/gpu_summary",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_metrics/gpu_summary.sql",
      "sha256": "4c6e65c01dde347eedce1d893c628ab6a614f03cd6b88db193dc1131489cd487",
      "signal_patterns": [
        "*GPU*",
        "*fence*",
        "*freq*",
        "*util*"
      ],
      "skill_id": "gpu_metrics",
      "source": {
        "path": "backend/skills/atomic/gpu_metrics.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "80fe51882560c325dcd072ed62a0c07db6b43a2fdf215b072b366077ec1fbf51"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gpu_summary",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "gpu_metrics"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "gpu_module/gpu_frequency_overview",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_module/gpu_frequency_overview.sql",
      "sha256": "c8c64b00fa5c15e159ddf864a5c4cd43f4fdeed309d52c0e72b83691f7f51212",
      "signal_patterns": [
        "gpufreq"
      ],
      "skill_id": "gpu_module",
      "source": {
        "path": "backend/skills/modules/hardware/gpu_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "579fe2d70ef30c53d7a5e32a06732ef2872ce8b45c31aea88cb079bf2a45c9e0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gpu_frequency_overview",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/gpu_frequency_intervals.sql",
            "source_sha256": "2bd8dac125b274ab3a3966e9f43ed780d0eef389b2eb5c0ee60e82fbfb5d6cba"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/gpu_descriptor_frequency_tracks.sql",
            "source_sha256": "a8285ba30e2e409ecf900beee1c6cc99e6cf6feb540387e0ab0eadf59a784652"
          }
        ],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "gpu_module/gpu_utilization",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_module/gpu_utilization.sql",
      "sha256": "be3a684cf8e0a379a35dd845d713e2db884ed8130b44aa94095623d14fd93741",
      "signal_patterns": [
        "%busy%",
        "%load%",
        "%util%"
      ],
      "skill_id": "gpu_module",
      "source": {
        "path": "backend/skills/modules/hardware/gpu_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "579fe2d70ef30c53d7a5e32a06732ef2872ce8b45c31aea88cb079bf2a45c9e0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gpu_utilization",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "gpu_module/render_thread_gpu",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_module/render_thread_gpu.sql",
      "sha256": "fa7d08728363cfe9b2a10539e9c7508e7b305ac1c71704f0a792224391260404",
      "signal_patterns": [
        "%draw%",
        "%flush%",
        "%swap%",
        "RenderThread"
      ],
      "skill_id": "gpu_module",
      "source": {
        "path": "backend/skills/modules/hardware/gpu_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "579fe2d70ef30c53d7a5e32a06732ef2872ce8b45c31aea88cb079bf2a45c9e0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "render_thread_gpu",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "gpu_module/slow_gpu_operations",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_module/slow_gpu_operations.sql",
      "sha256": "6f030af9b929c076b93f705fbe55581aa3e9fc9aac2b42ed2ee5e92ebb5f77b5",
      "signal_patterns": [
        "%draw%",
        "%eglSwap%",
        "%flush%"
      ],
      "skill_id": "gpu_module",
      "source": {
        "path": "backend/skills/modules/hardware/gpu_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "579fe2d70ef30c53d7a5e32a06732ef2872ce8b45c31aea88cb079bf2a45c9e0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "slow_gpu_operations",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "gpu_module"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "gpu_power_state_analysis/root",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_power_state_analysis/query.sql",
      "sha256": "5f4c5bb3b814b0b028dc1dea0f2728ea57a30d209e1c0acda738bf25f1ae3d61",
      "signal_patterns": [
        "gpufreq"
      ],
      "skill_id": "gpu_power_state_analysis",
      "source": {
        "path": "backend/skills/atomic/gpu_power_state_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "871f3507060112eb0aba2d1328f0c1c47a6e70c5865bb46d16ac0ff9ef8436bc"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/gpu_frequency_intervals.sql",
            "source_sha256": "2bd8dac125b274ab3a3966e9f43ed780d0eef389b2eb5c0ee60e82fbfb5d6cba"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/gpu_frequency_window.sql",
            "source_sha256": "f615d9d238a1c9aa1382d69f35e6adc7cb087cfefb0aad8cc117d774a1f6b17f"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/gpu_frequency_summary.sql",
            "source_sha256": "3e0a701cdd5e39f4b248ef4137a0928476716dbf4b74824cb29a40847d75387b"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts",
          "transition_threshold_pct"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "gpu_power_state_analysis"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "gpu_render_in_range/root",
      "identity": {
        "aliases": [
          "package"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_render_in_range/query.sql",
      "process_scope": {
        "limitations": [
          "Operation aggregates combine application and SurfaceFlinger slices; they are not application-only measurements."
        ],
        "role": "global_context"
      },
      "sha256": "08ec44a2419e0e01f4f6c3c85dac8e4afae745db5e4a07780e6a38ea3511945f",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*DrawFrame*",
        "*Fence*signal*",
        "*Flush*",
        "*GPU*",
        "*RenderThread*",
        "*dequeueBuffer*",
        "*doFrame*",
        "*eglSwap*",
        "*fence*signal*",
        "*fence*wait*",
        "*flush*",
        "*queueBuffer*",
        "*waitForFence*",
        "surfaceflinger"
      ],
      "skill_id": "gpu_render_in_range",
      "source": {
        "path": "backend/skills/atomic/gpu_render_in_range.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "38ed6d933c5140968f9055afed8bcf8cd34234097f70fd50d4f629045b720b2d"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "gpu_render_in_range"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "gpu"
        ]
      },
      "id": "gpu_v57_ai_diagnostics/data_check",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_v57_ai_diagnostics/data_check.sql",
      "sha256": "615ed174ce50ca1855f92c227cbc7a41d56304f940947881e10137c060618fee",
      "signal_patterns": [
        "architecture",
        "dimension_arg_set_id",
        "gpufreq",
        "machine_id",
        "ugpu"
      ],
      "skill_id": "gpu_v57_ai_diagnostics",
      "source": {
        "path": "backend/skills/composite/gpu_v57_ai_diagnostics.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "cc0be719cf724cb2c0f128f806abaa4a1cd942f6381a0b8e28a83ca9c4a876ab"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "intervals.overlap",
          "intervals.intersect"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "data_check",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/gpu_frequency_intervals.sql",
            "source_sha256": "2bd8dac125b274ab3a3966e9f43ed780d0eef389b2eb5c0ee60e82fbfb5d6cba"
          }
        ],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "gpu_v57_ai_diagnostics/gpu_inventory",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_v57_ai_diagnostics/gpu_inventory.sql",
      "sha256": "880ea360e02332a406fd5cbbbfc3a4bda89e7317ca6d7d364cae4e22ede931a4",
      "signal_patterns": [],
      "skill_id": "gpu_v57_ai_diagnostics",
      "source": {
        "path": "backend/skills/composite/gpu_v57_ai_diagnostics.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "cc0be719cf724cb2c0f128f806abaa4a1cd942f6381a0b8e28a83ca9c4a876ab"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "intervals.overlap",
          "intervals.intersect"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gpu_inventory",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "ugpu"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "gpu"
        ]
      },
      "id": "gpu_v57_ai_diagnostics/timeline_occupancy",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_v57_ai_diagnostics/timeline_occupancy.sql",
      "sha256": "8ccd93da0097523802ac8c3f536bcee4ada01cd737c2cc86f7996abff4e41bff",
      "signal_patterns": [],
      "skill_id": "gpu_v57_ai_diagnostics",
      "source": {
        "path": "backend/skills/composite/gpu_v57_ai_diagnostics.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "cc0be719cf724cb2c0f128f806abaa4a1cd942f6381a0b8e28a83ca9c4a876ab"
      },
      "sql_dependencies": {
        "creates": [
          {
            "kind": "table",
            "name": "__sp_v57_gpu_work"
          },
          {
            "kind": "table",
            "name": "__sp_v57_gpu_busy"
          }
        ],
        "declared_modules": [
          "intervals.overlap",
          "intervals.intersect"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "timeline_occupancy",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts",
          "ugpu"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "gpu_v57_ai_diagnostics/idle_gaps",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_v57_ai_diagnostics/idle_gaps.sql",
      "sha256": "faa0f23e9ee1787851051f93a2c70c24cfc3f9f5b3a0a86413d085cab42fe70f",
      "signal_patterns": [],
      "skill_id": "gpu_v57_ai_diagnostics",
      "source": {
        "path": "backend/skills/composite/gpu_v57_ai_diagnostics.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "cc0be719cf724cb2c0f128f806abaa4a1cd942f6381a0b8e28a83ca9c4a876ab"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "intervals.overlap",
          "intervals.intersect"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "__sp_v57_gpu_busy"
        ],
        "setup_queries": [
          "gpu_v57_ai_diagnostics/timeline_occupancy"
        ]
      },
      "step_id": "idle_gaps",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "max_rows"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "gpu_v57_ai_diagnostics/frequency_residency",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_v57_ai_diagnostics/frequency_residency.sql",
      "sha256": "7250a8e604cb34a694872b777d6e7d969613a4efce9cd4111160f7d1c860eb70",
      "signal_patterns": [
        "gpufreq"
      ],
      "skill_id": "gpu_v57_ai_diagnostics",
      "source": {
        "path": "backend/skills/composite/gpu_v57_ai_diagnostics.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "cc0be719cf724cb2c0f128f806abaa4a1cd942f6381a0b8e28a83ca9c4a876ab"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "intervals.overlap",
          "intervals.intersect"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "__sp_v57_gpu_busy"
        ],
        "setup_queries": [
          "gpu_v57_ai_diagnostics/timeline_occupancy"
        ]
      },
      "step_id": "frequency_residency",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/gpu_frequency_intervals.sql",
            "source_sha256": "2bd8dac125b274ab3a3966e9f43ed780d0eef389b2eb5c0ee60e82fbfb5d6cba"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/gpu_frequency_window.sql",
            "source_sha256": "f615d9d238a1c9aa1382d69f35e6adc7cb087cfefb0aad8cc117d774a1f6b17f"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/gpu_frequency_by_ugpu.sql",
            "source_sha256": "7d414ae09c0a1ceb09674f166d981a52570b194ca6dd50aef388931b6b952848"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts",
          "ugpu"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "gpu_v57_ai_diagnostics/dvfs_ramp_events",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_v57_ai_diagnostics/dvfs_ramp_events.sql",
      "sha256": "946bcf6a1da335a4ce33740589042e6a971b70a313dcef5c4dc9ec88df874f2b",
      "signal_patterns": [
        "gpufreq"
      ],
      "skill_id": "gpu_v57_ai_diagnostics",
      "source": {
        "path": "backend/skills/composite/gpu_v57_ai_diagnostics.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "cc0be719cf724cb2c0f128f806abaa4a1cd942f6381a0b8e28a83ca9c4a876ab"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "intervals.overlap",
          "intervals.intersect"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "__sp_v57_gpu_busy"
        ],
        "setup_queries": [
          "gpu_v57_ai_diagnostics/timeline_occupancy"
        ]
      },
      "step_id": "dvfs_ramp_events",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/gpu_frequency_intervals.sql",
            "source_sha256": "2bd8dac125b274ab3a3966e9f43ed780d0eef389b2eb5c0ee60e82fbfb5d6cba"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/gpu_frequency_window.sql",
            "source_sha256": "f615d9d238a1c9aa1382d69f35e6adc7cb087cfefb0aad8cc117d774a1f6b17f"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/gpu_frequency_by_ugpu.sql",
            "source_sha256": "7d414ae09c0a1ceb09674f166d981a52570b194ca6dd50aef388931b6b952848"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "max_rows",
          "start_ts",
          "target_freq_ratio",
          "ugpu"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "gpu_v57_ai_diagnostics/sustained_below_target_events",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_v57_ai_diagnostics/sustained_below_target_events.sql",
      "sha256": "7ce075a1c80028c7596a4c30dd11c8d278ec8174387247fda4776eea376402e0",
      "signal_patterns": [
        "Power",
        "Temperature",
        "gpufreq"
      ],
      "skill_id": "gpu_v57_ai_diagnostics",
      "source": {
        "path": "backend/skills/composite/gpu_v57_ai_diagnostics.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "cc0be719cf724cb2c0f128f806abaa4a1cd942f6381a0b8e28a83ca9c4a876ab"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "intervals.overlap",
          "intervals.intersect"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "__sp_v57_gpu_busy"
        ],
        "setup_queries": [
          "gpu_v57_ai_diagnostics/timeline_occupancy"
        ]
      },
      "step_id": "sustained_below_target_events",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/gpu_frequency_intervals.sql",
            "source_sha256": "2bd8dac125b274ab3a3966e9f43ed780d0eef389b2eb5c0ee60e82fbfb5d6cba"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/gpu_frequency_window.sql",
            "source_sha256": "f615d9d238a1c9aa1382d69f35e6adc7cb087cfefb0aad8cc117d774a1f6b17f"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/gpu_frequency_by_ugpu.sql",
            "source_sha256": "7d414ae09c0a1ceb09674f166d981a52570b194ca6dd50aef388931b6b952848"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "max_rows",
          "min_below_target_ns",
          "start_ts",
          "target_freq_ratio",
          "ugpu"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "gpu_v57_ai_diagnostics/no_data_contract",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/gpu_v57_ai_diagnostics/no_data_contract.sql",
      "sha256": "554e7fc4ba8859a32181885fe33385b643cd28175577b8f8b94cddcb3c659063",
      "signal_patterns": [],
      "skill_id": "gpu_v57_ai_diagnostics",
      "source": {
        "path": "backend/skills/composite/gpu_v57_ai_diagnostics.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "cc0be719cf724cb2c0f128f806abaa4a1cd942f6381a0b8e28a83ca9c4a876ab"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "intervals.overlap",
          "intervals.intersect"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": [
          "gpu_v57_ai_diagnostics/timeline_occupancy"
        ]
      },
      "step_id": "no_data_contract",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [
          "data_check"
        ],
        "result_references": [
          "data_check"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "gpu_v57_ai_diagnostics"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "input_events_in_range/root",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/input_events_in_range/query.sql",
      "sha256": "868b2cfff4656f924f1dc2914d3a0dafcbe4a33bc89b2856b9c7c1a087a3b0f8",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "input_events_in_range",
      "source": {
        "path": "backend/skills/atomic/input_events_in_range.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "2f7e2106533b513cd6e2c45f1e181159a07dfaa498feec67768c5d49595baec0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.input"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "android_input_events"
        ],
        "setup_queries": [
          "scrolling_analysis/input_data_fallback_view"
        ]
      },
      "step_id": "root",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/android_input_events_normalized.sql",
            "source_sha256": "f43bd5a184bdb678fda9a90f950048cfd659b52f11fe57dab107a7d13abd60a5"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/android_input_delivery_roles.sql",
            "source_sha256": "9e43fdd5a50a207f0da9be059a3163b5b691d3efd8077e524066a1379e3013e3"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/android_input_scoped_deliveries.sql",
            "source_sha256": "d714ec458a5ed924aa621caa3404b7580e066e6180e755a34236488b01944d72"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "event_action",
          "event_type",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "input_events_in_range"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "input_module/click_response_overview",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/input_module/click_response_overview.sql",
      "sha256": "b42ae7cd25eadb653992b2927ea5a7fee1f809be3292ba30b5b21c5ca6239534",
      "signal_patterns": [
        "%deliverInputEvent%",
        "%dispatchTouchEvent%"
      ],
      "skill_id": "input_module",
      "source": {
        "path": "backend/skills/modules/framework/input_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "e514d3ba027d776732f4f451e54e709f259d7b79e371ab403971fb4925dfa977"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.input"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "click_response_overview",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "input_module/slow_input_events",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/input_module/slow_input_events.sql",
      "sha256": "7c17fbbbee8c36b90cb060b3ce36d0c800f301db4b65857bb7d6f1bb2d642ec7",
      "signal_patterns": [
        "%deliverInputEvent%",
        "%dispatchTouchEvent%"
      ],
      "skill_id": "input_module",
      "source": {
        "path": "backend/skills/modules/framework/input_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "e514d3ba027d776732f4f451e54e709f259d7b79e371ab403971fb4925dfa977"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.input"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "slow_input_events",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "input_module/input_dispatch_timing",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/input_module/input_dispatch_timing.sql",
      "sha256": "5e7354b87ffe95d619832bc66645bfd2152a1c2cc5acb8091b4bae5340b8f965",
      "signal_patterns": [
        "%InputDispatcher%",
        "%InputReader%",
        "%deliverInputEvent%"
      ],
      "skill_id": "input_module",
      "source": {
        "path": "backend/skills/modules/framework/input_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "e514d3ba027d776732f4f451e54e709f259d7b79e371ab403971fb4925dfa977"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.input"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "input_dispatch_timing",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "input_module"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "input_to_frame_latency/vsync_period",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/input_to_frame_latency/vsync_period.sql",
      "sha256": "24b9acba105c67fb141e3267597fd78a5560788af6672e10b371302c708be1d2",
      "signal_patterns": [
        "VSYNC-app"
      ],
      "skill_id": "input_to_frame_latency",
      "source": {
        "path": "backend/skills/atomic/input_to_frame_latency.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "42ded4806d9a910a2d97e2c7894bbdc986e7195a4ed6d85a2ee0fa43c4ae4dfd"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.input"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "vsync_period",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "input_to_frame_latency/input_sampling_rate",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/input_to_frame_latency/input_sampling_rate.sql",
      "sha256": "f31a5aeacac6bd45e8d84bc690ea3b8ae320ce346837f091ac0f21d92a88478c",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "input_to_frame_latency",
      "source": {
        "path": "backend/skills/atomic/input_to_frame_latency.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "42ded4806d9a910a2d97e2c7894bbdc986e7195a4ed6d85a2ee0fa43c4ae4dfd"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.input"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "android_input_events"
        ],
        "setup_queries": [
          "scrolling_analysis/input_data_fallback_view"
        ]
      },
      "step_id": "input_sampling_rate",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/android_input_events_normalized.sql",
            "source_sha256": "f43bd5a184bdb678fda9a90f950048cfd659b52f11fe57dab107a7d13abd60a5"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "input_to_frame_latency/per_frame_latency",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/input_to_frame_latency/per_frame_latency.sql",
      "sha256": "935834b204a1481c70c7788009b3bb75ca8f5ab3a1f79c0af86b6bb6a306dcbd",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "VSYNC-app"
      ],
      "skill_id": "input_to_frame_latency",
      "source": {
        "path": "backend/skills/atomic/input_to_frame_latency.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "42ded4806d9a910a2d97e2c7894bbdc986e7195a4ed6d85a2ee0fa43c4ae4dfd"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.input"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "android_input_events"
        ],
        "setup_queries": [
          "scrolling_analysis/input_data_fallback_view"
        ]
      },
      "step_id": "per_frame_latency",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/android_input_events_normalized.sql",
            "source_sha256": "f43bd5a184bdb678fda9a90f950048cfd659b52f11fe57dab107a7d13abd60a5"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "event_action_filter",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "input_to_frame_latency/latency_statistics",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/input_to_frame_latency/latency_statistics.sql",
      "sha256": "1ec8952f82f0b4e8f183d526db1b3af476c1aa8362a86c439cb10288ca12ab74",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "VSYNC-app"
      ],
      "skill_id": "input_to_frame_latency",
      "source": {
        "path": "backend/skills/atomic/input_to_frame_latency.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "42ded4806d9a910a2d97e2c7894bbdc986e7195a4ed6d85a2ee0fa43c4ae4dfd"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.input"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "android_input_events"
        ],
        "setup_queries": [
          "scrolling_analysis/input_data_fallback_view"
        ]
      },
      "step_id": "latency_statistics",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/android_input_events_normalized.sql",
            "source_sha256": "f43bd5a184bdb678fda9a90f950048cfd659b52f11fe57dab107a7d13abd60a5"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "input_to_frame_latency/latency_spikes",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/input_to_frame_latency/latency_spikes.sql",
      "sha256": "60f41aa6b493b5cb59ca30a066606df0b5595da77d2fcbef7f504b150d70331e",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "input_to_frame_latency",
      "source": {
        "path": "backend/skills/atomic/input_to_frame_latency.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "42ded4806d9a910a2d97e2c7894bbdc986e7195a4ed6d85a2ee0fa43c4ae4dfd"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.input"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [
          "android_input_events"
        ],
        "setup_queries": [
          "scrolling_analysis/input_data_fallback_view"
        ]
      },
      "step_id": "latency_spikes",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/android_input_events_normalized.sql",
            "source_sha256": "f43bd5a184bdb678fda9a90f950048cfd659b52f11fe57dab107a7d13abd60a5"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "input_to_frame_latency"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "io_pressure/data_check",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/io_pressure/data_check.sql",
      "sha256": "a1f029ac257076bf481342246dca1d27dca0c9971fcd9583db8eb95420d7873f",
      "signal_patterns": [],
      "skill_id": "io_pressure",
      "source": {
        "path": "backend/skills/composite/io_pressure.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "abd029a09336e7e2a849db7fba8b0e13357e976e20c5bd6fd7290e1997a29298"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.threads"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "data_check",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/io_blocked_function_families.sql",
            "source_sha256": "8d45506b0b20c30c432f555da5a21e293f3d290c55059f1cd3f508f77df72bb0"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "long_io_threshold_ms",
          "min_duration_ms",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "io_pressure/io_wait_overview",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/io_pressure/io_wait_overview.sql",
      "sha256": "981c148f1cb38773524c0afe844383ebe2b036e2884803e909799b21b8ec71e8",
      "signal_patterns": [],
      "skill_id": "io_pressure",
      "source": {
        "path": "backend/skills/composite/io_pressure.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "abd029a09336e7e2a849db7fba8b0e13357e976e20c5bd6fd7290e1997a29298"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.threads"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "io_wait_overview",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/io_blocked_function_families.sql",
            "source_sha256": "8d45506b0b20c30c432f555da5a21e293f3d290c55059f1cd3f508f77df72bb0"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "critical_io_wait_ms",
          "end_ts",
          "min_duration_ms",
          "start_ts",
          "warning_io_wait_ms"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "io_pressure/process_io_distribution",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/io_pressure/process_io_distribution.sql",
      "sha256": "a4666207111758c53b3ab96b1f445a1fb4264cc502f0330eab9eb857d84faaac",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "io_pressure",
      "source": {
        "path": "backend/skills/composite/io_pressure.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "abd029a09336e7e2a849db7fba8b0e13357e976e20c5bd6fd7290e1997a29298"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.threads"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "process_io_distribution",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/io_blocked_function_families.sql",
            "source_sha256": "8d45506b0b20c30c432f555da5a21e293f3d290c55059f1cd3f508f77df72bb0"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "max_items",
          "min_duration_ms",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "io_pressure/blocking_functions",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/io_pressure/blocking_functions.sql",
      "sha256": "639981ed46cb5695df7fc004a998dea87076a11cf3335c5b2521f2fc296209ca",
      "signal_patterns": [],
      "skill_id": "io_pressure",
      "source": {
        "path": "backend/skills/composite/io_pressure.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "abd029a09336e7e2a849db7fba8b0e13357e976e20c5bd6fd7290e1997a29298"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.threads"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "blocking_functions",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/io_blocked_function_families.sql",
            "source_sha256": "8d45506b0b20c30c432f555da5a21e293f3d290c55059f1cd3f508f77df72bb0"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "max_items",
          "min_duration_ms",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "io_pressure/thread_io_details",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/io_pressure/thread_io_details.sql",
      "sha256": "8cb45a8c4db9480923e23a26ce3d26c1a6a4e8e6116302968a4111556dd8e2c3",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "io_pressure",
      "source": {
        "path": "backend/skills/composite/io_pressure.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "abd029a09336e7e2a849db7fba8b0e13357e976e20c5bd6fd7290e1997a29298"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.threads"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "thread_io_details",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/io_blocked_function_families.sql",
            "source_sha256": "8d45506b0b20c30c432f555da5a21e293f3d290c55059f1cd3f508f77df72bb0"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "max_items",
          "min_duration_ms",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "io_pressure/long_io_events",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/io_pressure/long_io_events.sql",
      "sha256": "2294793b790e29805e993645233a720cb92350a8726a0c1db9d001d36c04a75f",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "io_pressure",
      "source": {
        "path": "backend/skills/composite/io_pressure.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "abd029a09336e7e2a849db7fba8b0e13357e976e20c5bd6fd7290e1997a29298"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.threads"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "long_io_events",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/io_blocked_function_families.sql",
            "source_sha256": "8d45506b0b20c30c432f555da5a21e293f3d290c55059f1cd3f508f77df72bb0"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "long_io_threshold_ms",
          "max_items",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "io_pressure/root_cause_classification",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/io_pressure/root_cause_classification.sql",
      "sha256": "7378a22c5eec080a838e1d00b5e930fd5c9d6d73eccfcb2f5a83beed6aba9033",
      "signal_patterns": [],
      "skill_id": "io_pressure",
      "source": {
        "path": "backend/skills/composite/io_pressure.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "abd029a09336e7e2a849db7fba8b0e13357e976e20c5bd6fd7290e1997a29298"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.threads"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root_cause_classification",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/io_blocked_function_families.sql",
            "source_sha256": "8d45506b0b20c30c432f555da5a21e293f3d290c55059f1cd3f508f77df72bb0"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "critical_io_wait_ms",
          "end_ts",
          "min_duration_ms",
          "start_ts",
          "warning_io_wait_ms"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "io_pressure"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "irq_analysis/data_check",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/irq_analysis/data_check.sql",
      "sha256": "6e1de1ba37824bb55a0d18f170a165ca10162267f9d3900ea68ed3aa79dd0cb7",
      "signal_patterns": [],
      "skill_id": "irq_analysis",
      "source": {
        "path": "backend/skills/composite/irq_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "fea29723032ba827d7c7b294e22ea8ff4633c9c6e8abb832895f9a9642a6e595"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.irqs"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "data_check",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "irq_analysis/irq_overview",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/irq_analysis/irq_overview.sql",
      "sha256": "20ac2fa7a6db42221e9b5563e2f1b8ff7e6485f7fd631a6fda70e4ce767beaf8",
      "signal_patterns": [],
      "skill_id": "irq_analysis",
      "source": {
        "path": "backend/skills/composite/irq_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "fea29723032ba827d7c7b294e22ea8ff4633c9c6e8abb832895f9a9642a6e595"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.irqs"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "irq_overview",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "irq_analysis/top_irq_sources",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/irq_analysis/top_irq_sources.sql",
      "sha256": "05d38ceee840943e205424d269a98fa17e9bfe79bbc10924ec84bc0f41ba03e5",
      "signal_patterns": [],
      "skill_id": "irq_analysis",
      "source": {
        "path": "backend/skills/composite/irq_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "fea29723032ba827d7c7b294e22ea8ff4633c9c6e8abb832895f9a9642a6e595"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.irqs"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "top_irq_sources",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "irq_analysis/hard_irq_detail",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/irq_analysis/hard_irq_detail.sql",
      "sha256": "cc7600a054e70807dd8c3802890547ea4fc6850f6bb1dc3fa7ac17b1c939c19e",
      "signal_patterns": [],
      "skill_id": "irq_analysis",
      "source": {
        "path": "backend/skills/composite/irq_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "fea29723032ba827d7c7b294e22ea8ff4633c9c6e8abb832895f9a9642a6e595"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.irqs"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "hard_irq_detail",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "hard_irq_long_threshold_us",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "irq_analysis/soft_irq_detail",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/irq_analysis/soft_irq_detail.sql",
      "sha256": "74eae67193514000bddaeac8b71096652e0a18e675d6c237536a6c3b77bf32b4",
      "signal_patterns": [],
      "skill_id": "irq_analysis",
      "source": {
        "path": "backend/skills/composite/irq_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "fea29723032ba827d7c7b294e22ea8ff4633c9c6e8abb832895f9a9642a6e595"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.irqs"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "soft_irq_detail",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "soft_irq_long_threshold_us",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "irq_analysis/long_irq_events",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/irq_analysis/long_irq_events.sql",
      "sha256": "57cdabdd56454adc1aba4607444ac7cf628624808f8aab57d6ac90d747a33035",
      "signal_patterns": [],
      "skill_id": "irq_analysis",
      "source": {
        "path": "backend/skills/composite/irq_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "fea29723032ba827d7c7b294e22ea8ff4633c9c6e8abb832895f9a9642a6e595"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.irqs"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "long_irq_events",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "hard_irq_long_threshold_us",
          "soft_irq_long_threshold_us",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "irq_analysis/irq_timeline",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/irq_analysis/irq_timeline.sql",
      "sha256": "993c120945c9db3e2d61fa71f5371f7a9b0f066cfdf144d18bcaac18ce222c9c",
      "signal_patterns": [],
      "skill_id": "irq_analysis",
      "source": {
        "path": "backend/skills/composite/irq_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "fea29723032ba827d7c7b294e22ea8ff4633c9c6e8abb832895f9a9642a6e595"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.irqs"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "irq_timeline",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "irq_analysis/root_cause_classification",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/irq_analysis/root_cause_classification.sql",
      "sha256": "348c5ec360c438547a8b29d3b723a5a9c696ca79c5bccbd59cbdc7a20250fcdc",
      "signal_patterns": [],
      "skill_id": "irq_analysis",
      "source": {
        "path": "backend/skills/composite/irq_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "fea29723032ba827d7c7b294e22ea8ff4633c9c6e8abb832895f9a9642a6e595"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.irqs"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root_cause_classification",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "hard_irq_long_threshold_us",
          "irq_dur_heavy_threshold_ms",
          "irq_rate_heavy_threshold",
          "soft_irq_long_threshold_us",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "irq_analysis/no_data_fallback",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/irq_analysis/no_data_fallback.sql",
      "sha256": "d5e1a709b246c9b976285673539b3f33b80e649598c535f6ce1c3711ed0ac373",
      "signal_patterns": [],
      "skill_id": "irq_analysis",
      "source": {
        "path": "backend/skills/composite/irq_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "fea29723032ba827d7c7b294e22ea8ff4633c9c6e8abb832895f9a9642a6e595"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.irqs"
        ],
        "drops": [],
        "required_tables": [
          "slice"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "no_data_fallback",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "irq_analysis"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "jank_frame_detail/monitor_contention_check",
      "identity": {
        "aliases": [
          "package",
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/jank_frame_detail/monitor_contention_check.sql",
      "process_scope": {
        "role": "identity_metadata"
      },
      "sha256": "8fc7a3298352f2c459d33e1291790841b2e526581b969f17e82542d599860fda",
      "signal_patterns": [
        "android_monitor_contention"
      ],
      "skill_id": "jank_frame_detail",
      "source": {
        "path": "backend/skills/composite/jank_frame_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "a0211e3d982714457a51437e411533797d8d6b214b85d9f67ce0d80ba4ad4c61"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "android.binder",
          "android.slices",
          "android.monitor_contention",
          "android.garbage_collection"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "monitor_contention_check",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "jank_frame_detail/gc_table_check",
      "identity": {
        "aliases": [
          "package",
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/jank_frame_detail/gc_table_check.sql",
      "process_scope": {
        "role": "identity_metadata"
      },
      "sha256": "a7cf12ec75f0eb55ea5688dd2f291d83feb61de0beea89d286c27f5150e2289a",
      "signal_patterns": [
        "android_garbage_collection_events"
      ],
      "skill_id": "jank_frame_detail",
      "source": {
        "path": "backend/skills/composite/jank_frame_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "a0211e3d982714457a51437e411533797d8d6b214b85d9f67ce0d80ba4ad4c61"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "android.binder",
          "android.slices",
          "android.monitor_contention",
          "android.garbage_collection"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gc_table_check",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "jank_frame_detail/gpu_table_check",
      "identity": {
        "aliases": [
          "package",
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/jank_frame_detail/gpu_table_check.sql",
      "process_scope": {
        "role": "identity_metadata"
      },
      "sha256": "adb7faac4af01501b46a7d345688f64267d685bbb40a9b9008b7e246699aaa2e",
      "signal_patterns": [
        "*Draw*",
        "*Fence*",
        "*eglSwap*",
        "RenderThread",
        "[0-9]*.raster",
        "gpufreq"
      ],
      "skill_id": "jank_frame_detail",
      "source": {
        "path": "backend/skills/composite/jank_frame_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "a0211e3d982714457a51437e411533797d8d6b214b85d9f67ce0d80ba4ad4c61"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "android.binder",
          "android.slices",
          "android.monitor_contention",
          "android.garbage_collection"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gpu_table_check",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/gpu_frequency_intervals.sql",
            "source_sha256": "2bd8dac125b274ab3a3966e9f43ed780d0eef389b2eb5c0ee60e82fbfb5d6cba"
          }
        ],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "jank_frame_detail/binder_table_check",
      "identity": {
        "aliases": [
          "package",
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/jank_frame_detail/binder_table_check.sql",
      "process_scope": {
        "role": "identity_metadata"
      },
      "sha256": "87f9433d21fe45cae7b10f5acd8b4d28afb7f0b9580a461c0d48d15b54a8f4e8",
      "signal_patterns": [
        "android_binder_txns"
      ],
      "skill_id": "jank_frame_detail",
      "source": {
        "path": "backend/skills/composite/jank_frame_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "a0211e3d982714457a51437e411533797d8d6b214b85d9f67ce0d80ba4ad4c61"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "android.binder",
          "android.slices",
          "android.monitor_contention",
          "android.garbage_collection"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "binder_table_check",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "jank_frame_detail/quadrant_analysis",
      "identity": {
        "aliases": [
          "package",
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/jank_frame_detail/quadrant_analysis.sql",
      "process_scope": {
        "binding": "native_upid",
        "role": "target"
      },
      "sha256": "f0463965c77f76928318eb2fdfc67b354e3e89364933be4683274453efb4fc0d",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "RenderThread",
        "[0-9]*.raster",
        "[0-9]*.ui"
      ],
      "skill_id": "jank_frame_detail",
      "source": {
        "path": "backend/skills/composite/jank_frame_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "a0211e3d982714457a51437e411533797d8d6b214b85d9f67ce0d80ba4ad4c61"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "android.binder",
          "android.slices",
          "android.monitor_contention",
          "android.garbage_collection"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "quadrant_analysis",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/system_sched_spans.sql",
            "source_sha256": "ebcdcc6f476c4109051e817bcd107b1e45351faea14ff238ba76fb3f53b0b032"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/system_thread_state_spans.sql",
            "source_sha256": "40a17843f23e9cd7a249735450ff58accb11c2ecb13ac8c22f3f9ff31bcadaa1"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/target_threads.sql",
            "source_sha256": "27897663141fd7d0e5e3e3ae9bdd5165b31fcacf58e50ee1deb1f68ad7f0617e"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "main_end_ts",
          "main_start_ts",
          "package",
          "render_end_ts",
          "render_start_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "jank_frame_detail/binder_calls",
      "identity": {
        "aliases": [
          "package",
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/jank_frame_detail/binder_calls.sql",
      "process_scope": {
        "binding": "native_upid",
        "context_fields": {
          "peer_context": [
            "interface"
          ]
        },
        "role": "target"
      },
      "sha256": "69ebb803b636bb6627cbff3e713678c11cc2e0dd103481f09adc9c8c4ff9b63d",
      "signal_patterns": [],
      "skill_id": "jank_frame_detail",
      "source": {
        "path": "backend/skills/composite/jank_frame_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "a0211e3d982714457a51437e411533797d8d6b214b85d9f67ce0d80ba4ad4c61"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "android.binder",
          "android.slices",
          "android.monitor_contention",
          "android.garbage_collection"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "binder_calls",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "jank_frame_detail/cpu_freq_analysis",
      "identity": {
        "aliases": [
          "package",
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/jank_frame_detail/cpu_freq_analysis.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "c153750259eb032202d86833e52d444af1b34e49e0b6766b6d3a94d1558315d8",
      "signal_patterns": [],
      "skill_id": "jank_frame_detail",
      "source": {
        "path": "backend/skills/composite/jank_frame_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "a0211e3d982714457a51437e411533797d8d6b214b85d9f67ce0d80ba4ad4c61"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "android.binder",
          "android.slices",
          "android.monitor_contention",
          "android.garbage_collection"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "cpu_freq_analysis",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/system_sched_spans.sql",
            "source_sha256": "ebcdcc6f476c4109051e817bcd107b1e45351faea14ff238ba76fb3f53b0b032"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/system_cpu_frequency_spans.sql",
            "source_sha256": "b874887b2a598182d29b088ea7b350d89687142dc07e8fb1c9dbc771c54b48b1"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "jank_frame_detail/main_thread_slices",
      "identity": {
        "aliases": [
          "package",
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/jank_frame_detail/main_thread_slices.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "e8fa8fbffdcb61f0589b4fa92e536e84ca96640f777ae5359bcf990657e6b11a",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "[0-9]*.ui"
      ],
      "skill_id": "jank_frame_detail",
      "source": {
        "path": "backend/skills/composite/jank_frame_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "a0211e3d982714457a51437e411533797d8d6b214b85d9f67ce0d80ba4ad4c61"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "android.binder",
          "android.slices",
          "android.monitor_contention",
          "android.garbage_collection"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "main_thread_slices",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "main_end_ts",
          "main_start_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "jank_frame_detail/choreographer_resync_markers",
      "identity": {
        "aliases": [
          "package",
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/jank_frame_detail/choreographer_resync_markers.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "85d5b5f8e6f8efed9ffac79d4a9354163067b51601d829e38a3e713950cbcb78",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "Choreographer#doFrame - resynced*",
        "[0-9]*.ui"
      ],
      "skill_id": "jank_frame_detail",
      "source": {
        "path": "backend/skills/composite/jank_frame_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "a0211e3d982714457a51437e411533797d8d6b214b85d9f67ce0d80ba4ad4c61"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "android.binder",
          "android.slices",
          "android.monitor_contention",
          "android.garbage_collection"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "choreographer_resync_markers",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "main_end_ts",
          "main_start_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "jank_frame_detail/render_thread_slices",
      "identity": {
        "aliases": [
          "package",
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/jank_frame_detail/render_thread_slices.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "53d1debd189e2aad4e95498aaaf11571eed83c3e0a28a8fa4b656258d03864b5",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "RenderThread",
        "[0-9]*.raster"
      ],
      "skill_id": "jank_frame_detail",
      "source": {
        "path": "backend/skills/composite/jank_frame_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "a0211e3d982714457a51437e411533797d8d6b214b85d9f67ce0d80ba4ad4c61"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "android.binder",
          "android.slices",
          "android.monitor_contention",
          "android.garbage_collection"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "render_thread_slices",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "render_end_ts",
          "render_start_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "jank_frame_detail/cpu_freq_timeline",
      "identity": {
        "aliases": [
          "package",
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/jank_frame_detail/cpu_freq_timeline.sql",
      "process_scope": {
        "role": "global_context"
      },
      "sha256": "c224f00d69d6764466686865356129b447ed688478bc5415cc3eda8c14029ae0",
      "signal_patterns": [],
      "skill_id": "jank_frame_detail",
      "source": {
        "path": "backend/skills/composite/jank_frame_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "a0211e3d982714457a51437e411533797d8d6b214b85d9f67ce0d80ba4ad4c61"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "android.binder",
          "android.slices",
          "android.monitor_contention",
          "android.garbage_collection"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "cpu_freq_timeline",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/system_sched_spans.sql",
            "source_sha256": "ebcdcc6f476c4109051e817bcd107b1e45351faea14ff238ba76fb3f53b0b032"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/system_cpu_frequency_spans.sql",
            "source_sha256": "b874887b2a598182d29b088ea7b350d89687142dc07e8fb1c9dbc771c54b48b1"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "jank_frame_detail/lock_contention",
      "identity": {
        "aliases": [
          "package",
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/jank_frame_detail/lock_contention.sql",
      "process_scope": {
        "binding": "native_upid",
        "context_fields": {
          "peer_context": [
            "blocking_method",
            "blocking_thread_name",
            "waiter_count"
          ]
        },
        "role": "target"
      },
      "sha256": "5273fcff4cdc304bc053da5a93410d38046ce6f06a01040883b7a57199cd9b5f",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "jank_frame_detail",
      "source": {
        "path": "backend/skills/composite/jank_frame_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "a0211e3d982714457a51437e411533797d8d6b214b85d9f67ce0d80ba4ad4c61"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "android.binder",
          "android.slices",
          "android.monitor_contention",
          "android.garbage_collection"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "lock_contention",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "jank_frame_detail/gc_in_frame",
      "identity": {
        "aliases": [
          "package",
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/jank_frame_detail/gc_in_frame.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "60459d507a161f8ec58a87ce2d7bacfeaf3001efaa714f6f254fe7e1e7f3756f",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "jank_frame_detail",
      "source": {
        "path": "backend/skills/composite/jank_frame_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "a0211e3d982714457a51437e411533797d8d6b214b85d9f67ce0d80ba4ad4c61"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "android.binder",
          "android.slices",
          "android.monitor_contention",
          "android.garbage_collection"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gc_in_frame",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "jank_frame_detail/io_blocking",
      "identity": {
        "aliases": [
          "package",
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/jank_frame_detail/io_blocking.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "d4974635a6090f75aeeb50f22d4cc10902e98b666bd2074e64283a7c58861b99",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "RenderThread",
        "[0-9]*.raster",
        "[0-9]*.ui"
      ],
      "skill_id": "jank_frame_detail",
      "source": {
        "path": "backend/skills/composite/jank_frame_detail.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "a0211e3d982714457a51437e411533797d8d6b214b85d9f67ce0d80ba4ad4c61"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.cpu.frequency",
          "android.binder",
          "android.slices",
          "android.monitor_contention",
          "android.garbage_collection"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "io_blocking",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/system_thread_state_spans.sql",
            "source_sha256": "40a17843f23e9cd7a249735450ff58accb11c2ecb13ac8c22f3f9ff31bcadaa1"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "jank_frame_detail/root_cause_summary",
      "identity": {
        "aliases": [
          "package",
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/jank_frame_detail/root_cause_summary.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "context_fields": {
          "global_context": [
            "frame_budget_ms",
            "primary_cause",
            "secondary_info",
            "ramp_to_high_ms",
            "freq_ramp_evidence"
          ],
          "peer_context": [
            "deep_reason"
          ]
        },
        "limitations": [
          "\u6839\u56e0\u5206\u7c7b\u7ed3\u5408\u76ee\u6807\u7ebf\u7a0b\u3001\u5168\u5c40 CPU/VSync \u8d44\u6e90\u53ca\u5bf9\u7aef\u4fe1\u606f\uff1b\u6df7\u5408\u89e3\u91ca\u6587\u672c\u4e0d\u662f\u76ee\u6807\u8fdb\u7a0b\u7684\u72ec\u7acb\u5b9e\u6d4b\u6307\u6807\u3002"
        ],
        "role": "target"
      },
      "sha256": "77587211be7fcd86845e09801e50247b4d421b8583494a577f6fb357200dfb92",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*Compile*",
        "*DrawFrame*",
        "*Fence*",
        "*Pipeline*Create*",
        "*Shader*

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "launcher_module/launcher_process",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/launcher_module/launcher_process.sql",
      "sha256": "7c829057715ee32f47d54e7eb1c5ced79f87ea904d7d99d98004f23eb866bde9",
      "signal_patterns": [
        "%Home%",
        "%Launcher%",
        "%home%",
        "%launcher%",
        "%lawnchair%",
        "%nexuslauncher%",
        "%trebuchet%"
      ],
      "skill_id": "launcher_module",
      "source": {
        "path": "backend/skills/modules/app/launcher_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "4c0d82a72e79c8ac5f42f5c57ff618e5bc0211d2d8f4c88c79642fbddd4ac263"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "launcher_process",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "launcher_module/launcher_main_thread",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/launcher_module/launcher_main_thread.sql",
      "sha256": "9289abd9bf6744e4a7d730d4293d6accd52a366e357eef106412c9f15af7fd9d",
      "signal_patterns": [
        "%Launcher%",
        "%launcher%",
        "%nexuslauncher%",
        "%trebuchet%"
      ],
      "skill_id": "launcher_module",
      "source": {
        "path": "backend/skills/modules/app/launcher_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "4c0d82a72e79c8ac5f42f5c57ff618e5bc0211d2d8f4c88c79642fbddd4ac263"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "launcher_main_thread",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "launcher_module/launcher_frames",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/launcher_module/launcher_frames.sql",
      "sha256": "a7bc91c7116ff37c1814afc4e969027fa90f10fabcb9b869225b04dbdca49965",
      "signal_patterns": [
        "%Launcher%",
        "%launcher%",
        "%nexuslauncher%",
        "%trebuchet%",
        "*Choreographer#doFrame*",
        "*DrawFrame*",
        "*doFrame*"
      ],
      "skill_id": "launcher_module",
      "source": {
        "path": "backend/skills/modules/app/launcher_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "4c0d82a72e79c8ac5f42f5c57ff618e5bc0211d2d8f4c88c79642fbddd4ac263"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "launcher_frames",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "launcher_module/widget_activities",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/launcher_module/widget_activities.sql",
      "sha256": "911de774b4ce95796634a837a3a4d0cf0c3e54b53c525801f3cb7d15d794dd36",
      "signal_patterns": [
        "%Launcher%",
        "%launcher%",
        "%nexuslauncher%",
        "%trebuchet%",
        "*AppWidget*",
        "*RemoteViews*",
        "*Widget*",
        "*widget*"
      ],
      "skill_id": "launcher_module",
      "source": {
        "path": "backend/skills/modules/app/launcher_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "4c0d82a72e79c8ac5f42f5c57ff618e5bc0211d2d8f4c88c79642fbddd4ac263"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "widget_activities",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "launcher_module/app_launch_events",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/launcher_module/app_launch_events.sql",
      "sha256": "eb8e822baa3bea6068a3f1e6a6ea87085e2f571f0d2ef299bdfd0a576d30f087",
      "signal_patterns": [
        "%Launcher%",
        "%launcher%",
        "%nexuslauncher%",
        "%trebuchet%",
        "*ItemClick*",
        "*launchApp*",
        "*onClick*",
        "*startActivity*",
        "*touch*"
      ],
      "skill_id": "launcher_module",
      "source": {
        "path": "backend/skills/modules/app/launcher_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "4c0d82a72e79c8ac5f42f5c57ff618e5bc0211d2d8f4c88c79642fbddd4ac263"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "app_launch_events",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "launcher_module/wallpaper_rendering",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/launcher_module/wallpaper_rendering.sql",
      "sha256": "e5ed75892ab501d1ee9b895c81413c874789636802580f639bcd5b10c2f426d8",
      "signal_patterns": [
        "*Wallpaper*",
        "*wallpaper*"
      ],
      "skill_id": "launcher_module",
      "source": {
        "path": "backend/skills/modules/app/launcher_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "4c0d82a72e79c8ac5f42f5c57ff618e5bc0211d2d8f4c88c79642fbddd4ac263"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "wallpaper_rendering",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "launcher_module/all_apps_drawer",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/launcher_module/all_apps_drawer.sql",
      "sha256": "02d3e196607907d73bc6a3c8bf6801948fbf2a2c3b3cfaa6f47c7dbb1621bce8",
      "signal_patterns": [
        "%Launcher%",
        "%launcher%",
        "%nexuslauncher%",
        "%trebuchet%",
        "*AllApps*",
        "*Drawer*",
        "*allapps*",
        "*drawer*"
      ],
      "skill_id": "launcher_module",
      "source": {
        "path": "backend/skills/modules/app/launcher_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "4c0d82a72e79c8ac5f42f5c57ff618e5bc0211d2d8f4c88c79642fbddd4ac263"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "all_apps_drawer",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "launcher_module/launcher_binder_calls",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/launcher_module/launcher_binder_calls.sql",
      "sha256": "7a639510b2df19c94216b1f465bb634c8769f5d9fa2f1b9cadc85b5b3091d1e3",
      "signal_patterns": [
        "%Launcher%",
        "%launcher%",
        "%nexuslauncher%",
        "%trebuchet%",
        "*AIDL*",
        "*Binder*",
        "*aidl*",
        "*binder*"
      ],
      "skill_id": "launcher_module",
      "source": {
        "path": "backend/skills/modules/app/launcher_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "4c0d82a72e79c8ac5f42f5c57ff618e5bc0211d2d8f4c88c79642fbddd4ac263"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "launcher_binder_calls",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "launcher_module"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "linux_irq_summary/irq_summary",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/linux_irq_summary/irq_summary.sql",
      "sha256": "cbd5cff23de71edb1b6538da6651661bb92a3967c7b3dfe7ff1544b1f67e5d6a",
      "signal_patterns": [],
      "skill_id": "linux_irq_summary",
      "source": {
        "path": "backend/skills/atomic/linux_irq_summary.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "5ed6c6bb88f94df602ca5a751e53d30bec9514dcbff8bb6ece838bfcb963369d"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.irqs"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "irq_summary",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "linux_irq_summary"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "linux_perf_counter_hotspots/perf_counter_hotspots",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/linux_perf_counter_hotspots/perf_counter_hotspots.sql",
      "sha256": "b03f3607117f040ba236e9a75d2a4d66b102c90254764384a08e2cc90576e0c4",
      "signal_patterns": [],
      "skill_id": "linux_perf_counter_hotspots",
      "source": {
        "path": "backend/skills/atomic/linux_perf_counter_hotspots.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "af7bb5a650cb5630f9a7660853cbc71766190fc42683c59a3cbdd8625d24f3aa"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.perf.counters"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "perf_counter_hotspots",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "package",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "linux_perf_counter_hotspots"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "linux_process_rss_swap_timeline/rss_swap_peaks",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/linux_process_rss_swap_timeline/rss_swap_peaks.sql",
      "sha256": "cce8621e317bb53a4d661b18ed702dfa127eb03956ea321dfdbf02f5785eeab0",
      "signal_patterns": [],
      "skill_id": "linux_process_rss_swap_timeline",
      "source": {
        "path": "backend/skills/atomic/linux_process_rss_swap_timeline.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "fa2db2d7e72b53fb5ad2fd529a8be2e71817754cc77655a857181afb81023a04"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.memory.process"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "rss_swap_peaks",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "package",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "linux_process_rss_swap_timeline"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "linux_runqueue_depth_timeline/runqueue_pressure_summary",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/linux_runqueue_depth_timeline/runqueue_pressure_summary.sql",
      "sha256": "2f7c8c814caefa83af666bf3fe073c4cb954118fd75a0602f6dcafbd05369997",
      "signal_patterns": [],
      "skill_id": "linux_runqueue_depth_timeline",
      "source": {
        "path": "backend/skills/atomic/linux_runqueue_depth_timeline.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "df8e54081665caab0f1d374c13f7ceb343c0f20209e1e1b699da6ee24688ba35"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "sched.thread_level_parallelism"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "runqueue_pressure_summary",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "pressure_threshold",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "linux_runqueue_depth_timeline/runqueue_pressure_windows",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/linux_runqueue_depth_timeline/runqueue_pressure_windows.sql",
      "sha256": "5c6774f88adf694d9accd67b179ae86fa6ca7897a8b9573e58ff906852da5936",
      "signal_patterns": [],
      "skill_id": "linux_runqueue_depth_timeline",
      "source": {
        "path": "backend/skills/atomic/linux_runqueue_depth_timeline.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "df8e54081665caab0f1d374c13f7ceb343c0f20209e1e1b699da6ee24688ba35"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "sched.thread_level_parallelism"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "runqueue_pressure_windows",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "pressure_threshold",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "linux_runqueue_depth_timeline"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "linux_sched_latency_distribution/sched_latency_distribution",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/linux_sched_latency_distribution/sched_latency_distribution.sql",
      "sha256": "4ccd8d88259aab922f794622b957e64bbcc55673cb5f20318932615bc2222d99",
      "signal_patterns": [],
      "skill_id": "linux_sched_latency_distribution",
      "source": {
        "path": "backend/skills/atomic/linux_sched_latency_distribution.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "6f1048ef8b33cde78b99d15f65295b15df07e2eb984f3b82147d6d8196ed480d"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "sched.latency"
        ],
        "drops": [],
        "required_tables": [
          "thread",
          "process",
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "sched_latency_distribution",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "package",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "linux_sched_latency_distribution"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "linux_systemd_journald_analysis/root",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/linux_systemd_journald_analysis/query.sql",
      "sha256": "32c5827a1f22ac991a2086eaed18d8e00620780efe2b37166a8e6bc11f596037",
      "signal_patterns": [],
      "skill_id": "linux_systemd_journald_analysis",
      "source": {
        "path": "backend/skills/atomic/linux_systemd_journald_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "73a21e2a0fac64fb3e80030be4225b2c9e9051438c21557277bedf2ac1988aa2"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.systemd_journald"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "max_prio",
          "max_rows",
          "start_ts",
          "tag",
          "unit"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "linux_systemd_journald_analysis"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "lmk_analysis/data_check",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lmk_analysis/data_check.sql",
      "sha256": "3d90816e11e6726f90c12abf48dadba09c70f8d178cfe24d171a0c1da95f011c",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "mem.free"
      ],
      "skill_id": "lmk_analysis",
      "source": {
        "path": "backend/skills/composite/lmk_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "380a21355baca5f8e2d2d740174e6f6897b0150f4d792c53f3b0d42de71a0f1b"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.lmk",
          "linux.memory.general"
        ],
        "drops": [],
        "required_tables": [
          "android_lmk_events"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "data_check",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "lmk_analysis/lmk_overview",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lmk_analysis/lmk_overview.sql",
      "sha256": "699d326e1682b4ba0c08203c11b11d872e49613a348cb829dd1457d4aaf414c7",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "lmk_analysis",
      "source": {
        "path": "backend/skills/composite/lmk_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "380a21355baca5f8e2d2d740174e6f6897b0150f4d792c53f3b0d42de71a0f1b"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.lmk",
          "linux.memory.general"
        ],
        "drops": [],
        "required_tables": [
          "android_lmk_events"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "lmk_overview",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "lmk_analysis/lmk_timeline",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lmk_analysis/lmk_timeline.sql",
      "sha256": "22465438343aa0806a1205316215ba545a28ad7aba383fb7a09a9abb0e12d6e3",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "lmk_analysis",
      "source": {
        "path": "backend/skills/composite/lmk_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "380a21355baca5f8e2d2d740174e6f6897b0150f4d792c53f3b0d42de71a0f1b"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.lmk",
          "linux.memory.general"
        ],
        "drops": [],
        "required_tables": [
          "android_lmk_events"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "lmk_timeline",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "oom_adj_threshold",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "lmk_analysis/high_priority_kills",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lmk_analysis/high_priority_kills.sql",
      "sha256": "ca61c38d23b8ed25de512eb319df6a8e41dfbdea7095d06a9f8728a5440fb459",
      "signal_patterns": [],
      "skill_id": "lmk_analysis",
      "source": {
        "path": "backend/skills/composite/lmk_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "380a21355baca5f8e2d2d740174e6f6897b0150f4d792c53f3b0d42de71a0f1b"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.lmk",
          "linux.memory.general"
        ],
        "drops": [],
        "required_tables": [
          "android_lmk_events"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "high_priority_kills",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "lmk_analysis/lmk_memory_context",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lmk_analysis/lmk_memory_context.sql",
      "sha256": "afc47f71648935655e957837f6093c9367bae97dca9e6ad934f8cf97fd5bd1cd",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "mem.available",
        "mem.free"
      ],
      "skill_id": "lmk_analysis",
      "source": {
        "path": "backend/skills/composite/lmk_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "380a21355baca5f8e2d2d740174e6f6897b0150f4d792c53f3b0d42de71a0f1b"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.lmk",
          "linux.memory.general"
        ],
        "drops": [],
        "required_tables": [
          "android_lmk_events"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "lmk_memory_context",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "lmk_analysis/lmk_frequency",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lmk_analysis/lmk_frequency.sql",
      "sha256": "d20371caabbf40bf9dbb08db846ede1316678388d2b8ad6e2d20514a30c1d3c7",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "lmk_analysis",
      "source": {
        "path": "backend/skills/composite/lmk_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "380a21355baca5f8e2d2d740174e6f6897b0150f4d792c53f3b0d42de71a0f1b"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.lmk",
          "linux.memory.general"
        ],
        "drops": [],
        "required_tables": [
          "android_lmk_events"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "lmk_frequency",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "lmk_analysis/process_restart_after_lmk",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lmk_analysis/process_restart_after_lmk.sql",
      "sha256": "5bf307c5b34e7dc833fe0c5b3802d78ce9708db417d4c4326ef3c703085aa06e",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "lmk_analysis",
      "source": {
        "path": "backend/skills/composite/lmk_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "380a21355baca5f8e2d2d740174e6f6897b0150f4d792c53f3b0d42de71a0f1b"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.lmk",
          "linux.memory.general"
        ],
        "drops": [],
        "required_tables": [
          "android_lmk_events"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "process_restart_after_lmk",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "lmk_analysis/root_cause_classification",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lmk_analysis/root_cause_classification.sql",
      "sha256": "6bd4ba6145fea89aec84fab110dbb32256935d24bde4adb5bdf6dfb7632c04ab",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "lmk_analysis",
      "source": {
        "path": "backend/skills/composite/lmk_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "380a21355baca5f8e2d2d740174e6f6897b0150f4d792c53f3b0d42de71a0f1b"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.lmk",
          "linux.memory.general"
        ],
        "drops": [],
        "required_tables": [
          "android_lmk_events"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root_cause_classification",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "lmk_analysis"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "lmk_kill_attribution/lmk_events",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lmk_kill_attribution/lmk_events.sql",
      "sha256": "6d84e2a2e69e2a3a2095c27323f0244affb7a957f9215cb2df57052d2d065382",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "lmk_kill_attribution",
      "source": {
        "path": "backend/skills/atomic/lmk_kill_attribution.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1f267129dd343f4693338d1c7e4384b88c383313fe1b950339e31f9c9dfa8c85"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.memory.lmk"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "lmk_events",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "lmk_kill_attribution"
}

{
  "queries": [],
  "schema_version": 1,
  "skill_id": "lock_binder_wait"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "lock_contention_analysis/data_check",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lock_contention_analysis/data_check.sql",
      "sha256": "e97c648655d8ad8bdae73332f879f2190dfe3c3cae2a3a48787e839f14a47676",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "lock_contention_analysis",
      "source": {
        "path": "backend/skills/composite/lock_contention_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "6cc30df6302970712dcfa515969800f74b30e65154d9f53f2cfcb10587191188"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.monitor_contention",
          "android.lock_held",
          "slices.with_context"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "data_check",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "lock_contention_analysis/owner_contention_events",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lock_contention_analysis/owner_contention_events.sql",
      "sha256": "629c86184a8e0af59f92e8e117e8a0a8d2168736dd91307144eebb2267605cd5",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*",
        "*monitor*",
        "*mutex*",
        "Lock contention*(owner tid: *)*"
      ],
      "skill_id": "lock_contention_analysis",
      "source": {
        "path": "backend/skills/composite/lock_contention_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "6cc30df6302970712dcfa515969800f74b30e65154d9f53f2cfcb10587191188"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.monitor_contention",
          "android.lock_held",
          "slices.with_context"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "owner_contention_events",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "min_duration_ms",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "lock_contention_analysis/contention_overview",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lock_contention_analysis/contention_overview.sql",
      "sha256": "24202353298f24fac2732b881ad47849f542e9d6537a0588ff3cb269c5716cc8",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "lock_contention_analysis",
      "source": {
        "path": "backend/skills/composite/lock_contention_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "6cc30df6302970712dcfa515969800f74b30e65154d9f53f2cfcb10587191188"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.monitor_contention",
          "android.lock_held",
          "slices.with_context"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "contention_overview",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "min_duration_ms",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "lock_contention_analysis/main_thread_contentions",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lock_contention_analysis/main_thread_contentions.sql",
      "sha256": "ba2733758c35d4d8e0f29125b9f06acd820e8ee6e667d3a819817d9af9801549",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "lock_contention_analysis",
      "source": {
        "path": "backend/skills/composite/lock_contention_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "6cc30df6302970712dcfa515969800f74b30e65154d9f53f2cfcb10587191188"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.monitor_contention",
          "android.lock_held",
          "slices.with_context"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "main_thread_contentions",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "min_duration_ms",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "lock_contention_analysis/hot_locks",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lock_contention_analysis/hot_locks.sql",
      "sha256": "947fea41029053fa25d85dbfae2b06d27f1102fd81e070c392fd3b23f40cb879",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "lock_contention_analysis",
      "source": {
        "path": "backend/skills/composite/lock_contention_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "6cc30df6302970712dcfa515969800f74b30e65154d9f53f2cfcb10587191188"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.monitor_contention",
          "android.lock_held",
          "slices.with_context"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "hot_locks",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "lock_contention_analysis/lock_chain_analysis",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lock_contention_analysis/lock_chain_analysis.sql",
      "sha256": "69c3723d9dbff51796ef544bfa7ffe34941e21a3f2952028d00a1e1e50aa6d27",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "lock_contention_analysis",
      "source": {
        "path": "backend/skills/composite/lock_contention_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "6cc30df6302970712dcfa515969800f74b30e65154d9f53f2cfcb10587191188"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.monitor_contention",
          "android.lock_held",
          "slices.with_context"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "lock_chain_analysis",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "lock_contention_analysis/blocking_thread_state",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lock_contention_analysis/blocking_thread_state.sql",
      "sha256": "423f8d6dd5643c693a56ca36b9006926ba9ca0b748aff8a7bded1a4aece08c39",
      "signal_patterns": [],
      "skill_id": "lock_contention_analysis",
      "source": {
        "path": "backend/skills/composite/lock_contention_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "6cc30df6302970712dcfa515969800f74b30e65154d9f53f2cfcb10587191188"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.monitor_contention",
          "android.lock_held",
          "slices.with_context"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "blocking_thread_state",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "lock_contention_analysis/blocking_functions",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lock_contention_analysis/blocking_functions.sql",
      "sha256": "4ba0cebae76674c7f76e74e9a12133c7153b9781c59c5731f3529655c58af836",
      "signal_patterns": [],
      "skill_id": "lock_contention_analysis",
      "source": {
        "path": "backend/skills/composite/lock_contention_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "6cc30df6302970712dcfa515969800f74b30e65154d9f53f2cfcb10587191188"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.monitor_contention",
          "android.lock_held",
          "slices.with_context"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "blocking_functions",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "lock_contention_analysis/contention_binder_correlation",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lock_contention_analysis/contention_binder_correlation.sql",
      "sha256": "bb7deec8309c0024871128781e069eaa681cc5a85476e0d95eb3023a1e6eeddf",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "lock_contention_analysis",
      "source": {
        "path": "backend/skills/composite/lock_contention_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "6cc30df6302970712dcfa515969800f74b30e65154d9f53f2cfcb10587191188"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.monitor_contention",
          "android.lock_held",
          "slices.with_context"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "contention_binder_correlation",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "min_duration_ms",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "lock_contention_analysis/lock_held_capability",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lock_contention_analysis/lock_held_capability.sql",
      "sha256": "259cdccaac2a654a5fbc4ced9b7164d64e7ab3a993a0e019acc6a8b9c00d8f68",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*",
        "*_lock_held",
        "android_lock_held"
      ],
      "skill_id": "lock_contention_analysis",
      "source": {
        "path": "backend/skills/composite/lock_contention_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "6cc30df6302970712dcfa515969800f74b30e65154d9f53f2cfcb10587191188"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.monitor_contention",
          "android.lock_held",
          "slices.with_context"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "lock_held_capability",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "process_name"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "lock_contention_analysis/lock_held_owner_summary",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lock_contention_analysis/lock_held_owner_summary.sql",
      "sha256": "f6098ade53684a141bf0fb95e2c02ddc5cf85bbde5bbb117a00a64c5bd211504",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "lock_contention_analysis",
      "source": {
        "path": "backend/skills/composite/lock_contention_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "6cc30df6302970712dcfa515969800f74b30e65154d9f53f2cfcb10587191188"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.monitor_contention",
          "android.lock_held",
          "slices.with_context"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "lock_held_owner_summary",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "lock_contention_analysis/lock_held_long_holds",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lock_contention_analysis/lock_held_long_holds.sql",
      "sha256": "aeda051962213941c850b7ff06a5a2b43d0c6389b43f30dbd9987ec57ed13127",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "lock_contention_analysis",
      "source": {
        "path": "backend/skills/composite/lock_contention_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "6cc30df6302970712dcfa515969800f74b30e65154d9f53f2cfcb10587191188"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.monitor_contention",
          "android.lock_held",
          "slices.with_context"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "lock_held_long_holds",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "min_duration_ms",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "lock_contention_analysis/root_cause_classification",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lock_contention_analysis/root_cause_classification.sql",
      "sha256": "a78fb1a360d9c92fd930bea1b2184914584728579cf3c2f2169f6d1219f1b156",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "lock_contention_analysis",
      "source": {
        "path": "backend/skills/composite/lock_contention_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "6cc30df6302970712dcfa515969800f74b30e65154d9f53f2cfcb10587191188"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.monitor_contention",
          "android.lock_held",
          "slices.with_context"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root_cause_classification",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "min_duration_ms",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "lock_contention_analysis/fallback_no_data",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lock_contention_analysis/fallback_no_data.sql",
      "sha256": "56630e03666c04ba1e575dc6233aeebf3c9675443336f923e9f1e25222e45d20",
      "signal_patterns": [],
      "skill_id": "lock_contention_analysis",
      "source": {
        "path": "backend/skills/composite/lock_contention_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "6cc30df6302970712dcfa515969800f74b30e65154d9f53f2cfcb10587191188"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.monitor_contention",
          "android.lock_held",
          "slices.with_context"
        ],
        "drops": [],
        "required_tables": [
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "fallback_no_data",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "lock_contention_analysis"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "lock_contention_in_range/monitor_contentions",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lock_contention_in_range/monitor_contentions.sql",
      "sha256": "b462cdd75ffcac37356ec1e8c09ce792a422cf91f3213d5d5feed2d4dd84b34d",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "lock_contention_in_range",
      "source": {
        "path": "backend/skills/atomic/lock_contention_in_range.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "660f675d614aec2af8885125bcb62d2a5410b5318a01e545990ff3642f53a566"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.monitor_contention",
          "slices.with_context"
        ],
        "drops": [],
        "required_tables": [
          "thread_state",
          "android_monitor_contention"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "monitor_contentions",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "lock_contention_in_range/owner_contentions",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lock_contention_in_range/owner_contentions.sql",
      "sha256": "ac20008cd0cea54bf2b2013001c2023b594b02c5472400d8ab70c19051b29736",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*monitor*",
        "*mutex*",
        "Lock contention*(owner tid: *)*"
      ],
      "skill_id": "lock_contention_in_range",
      "source": {
        "path": "backend/skills/atomic/lock_contention_in_range.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "660f675d614aec2af8885125bcb62d2a5410b5318a01e545990ff3642f53a566"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.monitor_contention",
          "slices.with_context"
        ],
        "drops": [],
        "required_tables": [
          "thread_state",
          "android_monitor_contention"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "owner_contentions",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "lock_contention_in_range/futex_waits",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lock_contention_in_range/futex_waits.sql",
      "sha256": "c4a6ea8e7c60e2b8fa03e52329e186110419633134599dda27b28e016eb50fc4",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "lock_contention_in_range",
      "source": {
        "path": "backend/skills/atomic/lock_contention_in_range.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "660f675d614aec2af8885125bcb62d2a5410b5318a01e545990ff3642f53a566"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.monitor_contention",
          "slices.with_context"
        ],
        "drops": [],
        "required_tables": [
          "thread_state",
          "android_monitor_contention"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "futex_waits",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "thread_states"
        ]
      },
      "id": "lock_contention_in_range/lock_summary",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lock_contention_in_range/lock_summary.sql",
      "sha256": "43dc53e4be407266f0c6a6a6c7f22c26bcf5532a82b234683c9774f8577944f7",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "lock_contention_in_range",
      "source": {
        "path": "backend/skills/atomic/lock_contention_in_range.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "660f675d614aec2af8885125bcb62d2a5410b5318a01e545990ff3642f53a566"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.monitor_contention",
          "slices.with_context"
        ],
        "drops": [],
        "required_tables": [
          "thread_state",
          "android_monitor_contention"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "lock_summary",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "lock_contention_in_range"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices",
          "thread_states"
        ]
      },
      "id": "lock_contention_module/lock_contention_overview",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lock_contention_module/lock_contention_overview.sql",
      "sha256": "6e19bf652f7d96bd317361e4d08b1a9a1727c44bf7524f6742946955b645f9b3",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*Lock*",
        "*Monitor*",
        "*Mutex*",
        "*contention*",
        "*futex*",
        "*lock*",
        "*monitor*",
        "*mutex*",
        "*wait*"
      ],
      "skill_id": "lock_contention_module",
      "source": {
        "path": "backend/skills/modules/kernel/lock_contention_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "106819ab92ac89738c756cd296dd1da8aac142910477fdb313a8dc616a50bd08"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process",
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "lock_contention_overview",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices",
          "thread_states"
        ]
      },
      "id": "lock_contention_module/monitor_contention",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lock_contention_module/monitor_contention.sql",
      "sha256": "c7ecc51c7523455b223756017087632a63842d152afa83e5d6388458b0c3f7c4",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*LockContention*",
        "*Monitor*",
        "*monitor*",
        "*synchronized*"
      ],
      "skill_id": "lock_contention_module",
      "source": {
        "path": "backend/skills/modules/kernel/lock_contention_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "106819ab92ac89738c756cd296dd1da8aac142910477fdb313a8dc616a50bd08"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process",
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "monitor_contention",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices",
          "thread_states"
        ]
      },
      "id": "lock_contention_module/blocked_threads",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lock_contention_module/blocked_threads.sql",
      "sha256": "6e0423a3e13ce9e9c8abbb14ab50d12ccecebe41f0dc6f89fc6a08795dec6122",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "lock_contention_module",
      "source": {
        "path": "backend/skills/modules/kernel/lock_contention_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "106819ab92ac89738c756cd296dd1da8aac142910477fdb313a8dc616a50bd08"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process",
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "blocked_threads",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices",
          "thread_states"
        ]
      },
      "id": "lock_contention_module/main_thread_locks",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lock_contention_module/main_thread_locks.sql",
      "sha256": "5587499e5c3c28d4506cb933c2337a24a6130bbd266a166a809270951928a0cc",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*Lock*",
        "*contention*",
        "*lock*",
        "*monitor*",
        "*mutex*",
        "*wait*"
      ],
      "skill_id": "lock_contention_module",
      "source": {
        "path": "backend/skills/modules/kernel/lock_contention_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "106819ab92ac89738c756cd296dd1da8aac142910477fdb313a8dc616a50bd08"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process",
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "main_thread_locks",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices",
          "thread_states"
        ]
      },
      "id": "lock_contention_module/binder_thread_locks",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lock_contention_module/binder_thread_locks.sql",
      "sha256": "c10fbd20ed451abdff20fa2a6fc17872f409bd6b300136acdf1fca226be7ef11",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "%Binder%",
        "*Lock*",
        "*contention*",
        "*lock*",
        "*mutex*"
      ],
      "skill_id": "lock_contention_module",
      "source": {
        "path": "backend/skills/modules/kernel/lock_contention_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "106819ab92ac89738c756cd296dd1da8aac142910477fdb313a8dc616a50bd08"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process",
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "binder_thread_locks",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices",
          "thread_states"
        ]
      },
      "id": "lock_contention_module/long_lock_holds",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lock_contention_module/long_lock_holds.sql",
      "sha256": "02d19f3ba82d0273033a38a9cece5ba7a495bc234e4bfe8ac6d191716a75de97",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*acquired*",
        "*holding*lock*",
        "*lock*held*",
        "*synchronized*"
      ],
      "skill_id": "lock_contention_module",
      "source": {
        "path": "backend/skills/modules/kernel/lock_contention_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "106819ab92ac89738c756cd296dd1da8aac142910477fdb313a8dc616a50bd08"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process",
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "long_lock_holds",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices",
          "thread_states"
        ]
      },
      "id": "lock_contention_module/thread_contention_pairs",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/lock_contention_module/thread_contention_pairs.sql",
      "sha256": "df553cbaeb2a4af4ea794747b35fe451d3d2ae747bd9b79105e224d3064b7ae8",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "lock_contention_module",
      "source": {
        "path": "backend/skills/modules/kernel/lock_contention_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "106819ab92ac89738c756cd296dd1da8aac142910477fdb313a8dc616a50bd08"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread",
          "process",
          "thread_state"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "thread_contention_pairs",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "lock_contention_module"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "logcat_analysis/root",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/logcat_analysis/query.sql",
      "sha256": "b0a11cad15bed90cf0119e08b894afa6fc06e75ca7cf3117fb729e87bc0a4cb5",
      "signal_patterns": [
        "*GC*"
      ],
      "skill_id": "logcat_analysis",
      "source": {
        "path": "backend/skills/atomic/logcat_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "4c006bf2fd2861d2f647a5ad1a5b282ebec951cf2ec824f792431262fb8769cb"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "android_logs"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/art_gc_names.sql",
            "source_sha256": "2e50cd240ecb068815a92c13ff38fe2ea843172eece9818b3ed8bfd05f43dfd5"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "logcat_analysis"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "longest_process_slices/root",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/longest_process_slices/query.sql",
      "sha256": "ac4d152d5210fff72e3bb24d4307a83dfcb133a1042ea287f026faf0d8879bf5",
      "signal_patterns": [],
      "skill_id": "longest_process_slices",
      "source": {
        "path": "backend/skills/atomic/longest_process_slices.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "afd2f8caa3379888693e359840046ddb1c854202cdfe90578fc67ddd9a4916a8"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "track",
          "thread_track",
          "thread",
          "process",
          "process_track"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "max_rows",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "longest_process_slices"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "main_thread_file_io_in_range/root",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/main_thread_file_io_in_range/query.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "eaf0d4e8e2ffdf20463f82d39f81ef54a317c4347a2317876350f24de42d23ac",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "main_thread_file_io_in_range",
      "source": {
        "path": "backend/skills/atomic/main_thread_file_io_in_range.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "db85d5ef795370e46144f4a77826187da162576690574521104a414748ccd651"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/file_io_slice_names.sql",
            "source_sha256": "c93482a31b7576ab8570803e1b6c9c68beaaed8a9a7eef690e385bb26ec443ed"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "min_dur_ns",
          "package",
          "start_ts",
          "top_k"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "main_thread_file_io_in_range"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "slices",
          "thread_states"
        ]
      },
      "id": "main_thread_frame_work/system_context_window",
      "identity": {
        "aliases": [
          "package",
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/main_thread_frame_work/system_context_window.sql",
      "process_scope": {
        "role": "identity_metadata"
      },
      "sha256": "bbd5d1d4abf323894c203a88239272010c3a14977656f7b869b73462fa4e0efc",
      "signal_patterns": [],
      "skill_id": "main_thread_frame_work",
      "source": {
        "path": "backend/skills/composite/main_thread_frame_work.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "335e554b31f16b090c6d224e21718bd9e2c194ef268a06f9efdf4a36c9ec79d0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread_track",
          "thread_state",
          "thread",
          "process",
          "trace_bounds"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "system_context_window",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "slices",
          "thread_states"
        ]
      },
      "id": "main_thread_frame_work/main_thread_work_summary",
      "identity": {
        "aliases": [
          "package",
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/main_thread_frame_work/main_thread_work_summary.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "6e5acff81485db8cabbc93b338fed3a496c54b9f599674095df9ae1a6e478460",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "Choreographer#doFrame*",
        "doFrame"
      ],
      "skill_id": "main_thread_frame_work",
      "source": {
        "path": "backend/skills/composite/main_thread_frame_work.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "335e554b31f16b090c6d224e21718bd9e2c194ef268a06f9efdf4a36c9ec79d0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread_track",
          "thread_state",
          "thread",
          "process",
          "trace_bounds"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "main_thread_work_summary",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/main_thread_work.sql",
            "source_sha256": "27ed3844aa7a4a28c4580b7d329535d83b3917be428e06d7a0e57cfd7df2e8f7"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "main_thread_top_k",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "slices",
          "thread_states"
        ]
      },
      "id": "main_thread_frame_work/main_thread_work_tasks",
      "identity": {
        "aliases": [
          "package",
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/main_thread_frame_work/main_thread_work_tasks.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "debf4c8f478528e77dd0262035b15f18a9a0369662eca0bf5f912f8ba049dc5e",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "Choreographer#doFrame*",
        "doFrame"
      ],
      "skill_id": "main_thread_frame_work",
      "source": {
        "path": "backend/skills/composite/main_thread_frame_work.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "335e554b31f16b090c6d224e21718bd9e2c194ef268a06f9efdf4a36c9ec79d0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread_track",
          "thread_state",
          "thread",
          "process",
          "trace_bounds"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "main_thread_work_tasks",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/main_thread_work.sql",
            "source_sha256": "27ed3844aa7a4a28c4580b7d329535d83b3917be428e06d7a0e57cfd7df2e8f7"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/main_thread_work_tasks.sql",
            "source_sha256": "bdd5f064b9195ce7472d12ad3e8ef92dc54e958e5a96df1a29f83283f25841e5"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "main_thread_top_k",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "slices",
          "thread_states"
        ]
      },
      "id": "main_thread_frame_work/main_thread_work_sources",
      "identity": {
        "aliases": [
          "package",
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/main_thread_frame_work/main_thread_work_sources.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "bf41b995686bddfccbdfa3e0f225acde4ed115545368585f6df10395d6d862e6",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "Choreographer#doFrame*",
        "doFrame"
      ],
      "skill_id": "main_thread_frame_work",
      "source": {
        "path": "backend/skills/composite/main_thread_frame_work.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "335e554b31f16b090c6d224e21718bd9e2c194ef268a06f9efdf4a36c9ec79d0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread_track",
          "thread_state",
          "thread",
          "process",
          "trace_bounds"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "main_thread_work_sources",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/main_thread_work.sql",
            "source_sha256": "27ed3844aa7a4a28c4580b7d329535d83b3917be428e06d7a0e57cfd7df2e8f7"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/main_thread_work_tasks.sql",
            "source_sha256": "bdd5f064b9195ce7472d12ad3e8ef92dc54e958e5a96df1a29f83283f25841e5"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "main_thread_top_k",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": [
          "slices",
          "thread_states"
        ]
      },
      "id": "main_thread_frame_work/main_thread_work_cadence",
      "identity": {
        "aliases": [
          "package",
          "process_name"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/main_thread_frame_work/main_thread_work_cadence.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "c75b72276506517c8496cd214edc6976abe434559ec40516076117b5cc1c9124",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "Choreographer#doFrame*",
        "doFrame"
      ],
      "skill_id": "main_thread_frame_work",
      "source": {
        "path": "backend/skills/composite/main_thread_frame_work.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "335e554b31f16b090c6d224e21718bd9e2c194ef268a06f9efdf4a36c9ec79d0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "slice",
          "thread_track",
          "thread_state",
          "thread",
          "process",
          "trace_bounds"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "main_thread_work_cadence",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/main_thread_work.sql",
            "source_sha256": "27ed3844aa7a4a28c4580b7d329535d83b3917be428e06d7a0e57cfd7df2e8f7"
          },
          {
            "order": 2,
            "source_path": "backend/skills/fragments/main_thread_work_cadence.sql",
            "source_sha256": "f40d4ce6442a82c8d58b0a7dfa106c5407a10345863261ff40514eecb8872186"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "main_thread_top_k",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "main_thread_frame_work"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "fixtures": [
              "startup-heavy-api36",
              "startup-heavy-api36"
            ],
            "status": "verified"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "main_thread_handler_callback_slices/callback_slices",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/main_thread_handler_callback_slices/callback_slices.sql",
      "sha256": "c1e0102f747215cf12d007dace7e5e383409eaaf7cbec5374d460796ea8db744",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*Handler: *"
      ],
      "skill_id": "main_thread_handler_callback_slices",
      "source": {
        "path": "backend/skills/atomic/main_thread_handler_callback_slices.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "33502513a6be13a722153be01a9eebf84781088e428b1ccd383a3b8f72f0d1de"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.slices"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "thread_track",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "callback_slices",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "min_dur_ns",
          "package",
          "start_ts",
          "top_k"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "verified",
        "execution_verified": true,
        "fixtures": [
          "startup-heavy-api36"
        ],
        "runtime_compatible": true,
        "semantic_verified": true,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "main_thread_handler_callback_slices"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "main_thread_sched_latency_in_range/root",
      "identity": {
        "aliases": [
          "package"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/main_thread_sched_latency_in_range/query.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "baf5976110bd1c217488c745fcaa1228b85605bd40b6e016a08e921cb85c9dea",
      "signal_patterns": [
        "${package}:*"
      ],
      "skill_id": "main_thread_sched_latency_in_range",
      "source": {
        "path": "backend/skills/atomic/main_thread_sched_latency_in_range.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "25796e77489a0150ba0ca1775de82f09af9d446077367211baa918f5bf225b1f"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/system_thread_state_spans.sql",
            "source_sha256": "40a17843f23e9cd7a249735450ff58accb11c2ecb13ac8c22f3f9ff31bcadaa1"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "main_thread_sched_latency_in_range"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "main_thread_slices_in_range/root",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/main_thread_slices_in_range/query.sql",
      "process_scope": {
        "binding": "native_upid",
        "role": "target"
      },
      "sha256": "2798246ac9df2afb9a488e367f7f875606fec43d1d7ebd159078d6a62d0a561e",
      "signal_patterns": [
        "${package|}",
        "${package|}:*"
      ],
      "skill_id": "main_thread_slices_in_range",
      "source": {
        "path": "backend/skills/atomic/main_thread_slices_in_range.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "12e21a9345bfc67e7283f666038ad610196398f3d2adaed39a15a5d0c6681fa7"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "min_dur_ns",
          "package",
          "pid",
          "start_ts",
          "top_k",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "main_thread_slices_in_range"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "main_thread_states_in_range/root",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/main_thread_states_in_range/query.sql",
      "process_scope": {
        "binding": "native_upid",
        "role": "target"
      },
      "sha256": "e902409d89fb2f25d6319d2a84c109f14606aeb5c38d61a6379903386dfedaa8",
      "signal_patterns": [
        "${package|}",
        "${package|}:*"
      ],
      "skill_id": "main_thread_states_in_range",
      "source": {
        "path": "backend/skills/atomic/main_thread_states_in_range.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "7bad768d4547674b19d7268f5385de1b17e3746f458a9f2eaee723f02edde5c4"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/io_blocked_function_families.sql",
            "source_sha256": "8d45506b0b20c30c432f555da5a21e293f3d290c55059f1cd3f508f77df72bb0"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "pid",
          "start_ts",
          "top_k",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "main_thread_states_in_range"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "mali_gpu_power_state/mali_state",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/mali_gpu_power_state/mali_state.sql",
      "sha256": "57a7175e9fe67f53783d70449e810924599012804d186c65ea9d6660ece808df",
      "signal_patterns": [],
      "skill_id": "mali_gpu_power_state",
      "source": {
        "path": "backend/skills/atomic/mali_gpu_power_state.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "2846582cac7aa964a047a495575cb21b1517b7d63bf7d6bc261baf43847ed6db"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.gpu.mali_power_state"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "mali_state",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "mali_gpu_power_state"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "media_codec_activity/codec_activity_summary",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/media_codec_activity/codec_activity_summary.sql",
      "sha256": "b758abb8ada586d65102401246126cf91f6e191fad494496ea541b471596a7a7",
      "signal_patterns": [
        "*C2*",
        "*CCodec*",
        "*Codec2*",
        "*MediaCodec*",
        "*OMX*",
        "*dequeueInputBuffer*",
        "*dequeueOutputBuffer*",
        "*queueInputBuffer*",
        "*releaseOutputBuffer*"
      ],
      "skill_id": "media_codec_activity",
      "source": {
        "path": "backend/skills/atomic/media_codec_activity.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1eed98f1ef0dddad54b53d18061e82ff70bc9d6c559208cc408bdc2316f06cfe"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "slices.with_context"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "thread_track",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "codec_activity_summary",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "package",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "media_codec_activity/slow_codec_events",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/media_codec_activity/slow_codec_events.sql",
      "sha256": "9db58d35e72a86f6da418779109d995a7827416b8d8c78fa9213e9f8ec9a11a5",
      "signal_patterns": [
        "*C2*",
        "*CCodec*",
        "*Codec2*",
        "*MediaCodec*",
        "*OMX*",
        "*dequeueInputBuffer*",
        "*dequeueOutputBuffer*",
        "*queueInputBuffer*",
        "*releaseOutputBuffer*"
      ],
      "skill_id": "media_codec_activity",
      "source": {
        "path": "backend/skills/atomic/media_codec_activity.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1eed98f1ef0dddad54b53d18061e82ff70bc9d6c559208cc408bdc2316f06cfe"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "slices.with_context"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "thread_track",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "slow_codec_events",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "package",
          "process_name",
          "slow_threshold_ms",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "media_codec_activity"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "memory_analysis/get_process",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/memory_analysis/get_process.sql",
      "sha256": "df586097f2d1ca2ceb921a91a13daecd6399ac9ce074874c48c7df9491349576",
      "signal_patterns": [
        "${package}",
        "${package}:*"
      ],
      "skill_id": "memory_analysis",
      "source": {
        "path": "backend/skills/composite/memory_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1fb350c1d3eb4af09e605373da275721d9521ff7f20b34a245513f545b5b6dd1"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "get_process",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "memory_analysis/gc_overview",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/memory_analysis/gc_overview.sql",
      "sha256": "45760009eb2dcae56fd657a7565a381f8113444a28f1d88cae6b21c86b0a89f5",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*GC*"
      ],
      "skill_id": "memory_analysis",
      "source": {
        "path": "backend/skills/composite/memory_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1fb350c1d3eb4af09e605373da275721d9521ff7f20b34a245513f545b5b6dd1"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gc_overview",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/art_gc_names.sql",
            "source_sha256": "2e50cd240ecb068815a92c13ff38fe2ea843172eece9818b3ed8bfd05f43dfd5"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/memory_gc_events.sql",
            "source_sha256": "f682124224f533bdb40865b3a859b2d702a90fdc6899dc377b307e0c4e33d569"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "gc_count_critical",
          "gc_count_warning",
          "gc_total_time_critical_ms",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "memory_analysis/gc_stats",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/memory_analysis/gc_stats.sql",
      "sha256": "97efdeb9f73f99b0983c6db367b82c633ed39e56b836b3c28285c581df69810c",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*GC*"
      ],
      "skill_id": "memory_analysis",
      "source": {
        "path": "backend/skills/composite/memory_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1fb350c1d3eb4af09e605373da275721d9521ff7f20b34a245513f545b5b6dd1"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gc_stats",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/art_gc_names.sql",
            "source_sha256": "2e50cd240ecb068815a92c13ff38fe2ea843172eece9818b3ed8bfd05f43dfd5"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/memory_gc_events.sql",
            "source_sha256": "f682124224f533bdb40865b3a859b2d702a90fdc6899dc377b307e0c4e33d569"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "memory_analysis/gc_frame_impact",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/memory_analysis/gc_frame_impact.sql",
      "sha256": "907cb4c517d191eb5a847a6d8e3a56ca1cc32341cc95475723fa891a18305260",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*GC*"
      ],
      "skill_id": "memory_analysis",
      "source": {
        "path": "backend/skills/composite/memory_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1fb350c1d3eb4af09e605373da275721d9521ff7f20b34a245513f545b5b6dd1"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gc_frame_impact",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/art_gc_names.sql",
            "source_sha256": "2e50cd240ecb068815a92c13ff38fe2ea843172eece9818b3ed8bfd05f43dfd5"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/memory_gc_events.sql",
            "source_sha256": "f682124224f533bdb40865b3a859b2d702a90fdc6899dc377b307e0c4e33d569"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [
          "vsync_info"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "memory_analysis/main_thread_gc",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/memory_analysis/main_thread_gc.sql",
      "sha256": "b1557eceb7b2eceaacda00dbdde4967a7e1f3d3822c6c12f08f6a6cccd0fe782",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*GC*"
      ],
      "skill_id": "memory_analysis",
      "source": {
        "path": "backend/skills/composite/memory_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1fb350c1d3eb4af09e605373da275721d9521ff7f20b34a245513f545b5b6dd1"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "main_thread_gc",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/art_gc_names.sql",
            "source_sha256": "2e50cd240ecb068815a92c13ff38fe2ea843172eece9818b3ed8bfd05f43dfd5"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/memory_gc_events.sql",
            "source_sha256": "f682124224f533bdb40865b3a859b2d702a90fdc6899dc377b307e0c4e33d569"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "single_gc_warning_ms",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [
          "vsync_info"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "memory_analysis/gc_thread_state",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/memory_analysis/gc_thread_state.sql",
      "sha256": "9b19b68eb4f7121b3e1b75bd8475a2c10e910268f5632dca0e015046f5470366",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*GC*"
      ],
      "skill_id": "memory_analysis",
      "source": {
        "path": "backend/skills/composite/memory_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1fb350c1d3eb4af09e605373da275721d9521ff7f20b34a245513f545b5b6dd1"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gc_thread_state",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/art_gc_names.sql",
            "source_sha256": "2e50cd240ecb068815a92c13ff38fe2ea843172eece9818b3ed8bfd05f43dfd5"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/memory_gc_events.sql",
            "source_sha256": "f682124224f533bdb40865b3a859b2d702a90fdc6899dc377b307e0c4e33d569"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "memory_analysis/gc_interval_analysis",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/memory_analysis/gc_interval_analysis.sql",
      "sha256": "678da50b8615061e430388d53bd302ead24b5824ac1df3a8cd3f019ea5cc7abd",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*GC*"
      ],
      "skill_id": "memory_analysis",
      "source": {
        "path": "backend/skills/composite/memory_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1fb350c1d3eb4af09e605373da275721d9521ff7f20b34a245513f545b5b6dd1"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "gc_interval_analysis",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/art_gc_names.sql",
            "source_sha256": "2e50cd240ecb068815a92c13ff38fe2ea843172eece9818b3ed8bfd05f43dfd5"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/memory_gc_events.sql",
            "source_sha256": "f682124224f533bdb40865b3a859b2d702a90fdc6899dc377b307e0c4e33d569"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "memory_analysis/long_gc_events",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/memory_analysis/long_gc_events.sql",
      "sha256": "1cdef62d1378140057dfe600406a48b8436f86bd17e81afe997ba676c1e6513f",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*GC*"
      ],
      "skill_id": "memory_analysis",
      "source": {
        "path": "backend/skills/composite/memory_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1fb350c1d3eb4af09e605373da275721d9521ff7f20b34a245513f545b5b6dd1"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "long_gc_events",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/art_gc_names.sql",
            "source_sha256": "2e50cd240ecb068815a92c13ff38fe2ea843172eece9818b3ed8bfd05f43dfd5"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/memory_gc_events.sql",
            "source_sha256": "f682124224f533bdb40865b3a859b2d702a90fdc6899dc377b307e0c4e33d569"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "memory_analysis"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "memory_growth_detector/memory_growth",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/memory_growth_detector/memory_growth.sql",
      "sha256": "8757f6e98b8a352ec9131265cb05e4dfaf699ed3baf8debd82544d69d149f1da",
      "signal_patterns": [],
      "skill_id": "memory_growth_detector",
      "source": {
        "path": "backend/skills/atomic/memory_growth_detector.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "d2d0eb1ea2116db5a9fd472a64528119adcd7f007ee53fdc2d2eb53c778d9024"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.memory.process"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "memory_growth",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "growth_critical_pct",
          "growth_pct_min_mb",
          "growth_warning_mb",
          "growth_warning_pct",
          "jump_warning_mb",
          "package",
          "peak_avg_warning_ratio",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "memory_growth_detector"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "memory_module/memory_overview",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/memory_module/memory_overview.sql",
      "sha256": "d19298a56ba2ffdab978868269aec35d69122c0ab054d5e2256f2698f4310447",
      "signal_patterns": [
        "%Buffers%",
        "%Cached%",
        "%Mem%",
        "%MemAvailable%",
        "%MemFree%",
        "%Memory%",
        "%SwapFree%",
        "%mem%",
        "%memory%"
      ],
      "skill_id": "memory_module",
      "source": {
        "path": "backend/skills/modules/hardware/memory_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "b987a26840357de829425e1b7deba3e412dee91d2541ade4ad72e4866c5c38ff"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "counter",
          "counter_track"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "memory_overview",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "memory_module/lmk_events",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/memory_module/lmk_events.sql",
      "sha256": "7d29e92edb5686c3ac64bd9cccbd61cd6c826f2291997a8c40128054da9192f2",
      "signal_patterns": [
        "*LMK*",
        "*OOM*",
        "*kill*memory*",
        "*lmk*",
        "*lowmemory*",
        "*oom*"
      ],
      "skill_id": "memory_module",
      "source": {
        "path": "backend/skills/modules/hardware/memory_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "b987a26840357de829425e1b7deba3e412dee91d2541ade4ad72e4866c5c38ff"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "counter",
          "counter_track"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "lmk_events",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "memory_module/dmabuf_usage",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/memory_module/dmabuf_usage.sql",
      "sha256": "858675b4cc60e9521f604cfa5ae78da49eed401b25231bdb0613e90b7eac8bdc",
      "signal_patterns": [
        "*dmabuf*",
        "*gpu*mem*",
        "*graphics*",
        "*ion*"
      ],
      "skill_id": "memory_module",
      "source": {
        "path": "backend/skills/modules/hardware/memory_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "b987a26840357de829425e1b7deba3e412dee91d2541ade4ad72e4866c5c38ff"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "counter",
          "counter_track"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "dmabuf_usage",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "memory_module/memory_psi",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/memory_module/memory_psi.sql",
      "sha256": "8b274dfedabe4de817b887f4a593fa15efb409bfc691662f161492317669b012",
      "signal_patterns": [
        "*PSI*",
        "*pressure*",
        "*psi*"
      ],
      "skill_id": "memory_module",
      "source": {
        "path": "backend/skills/modules/hardware/memory_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "b987a26840357de829425e1b7deba3e412dee91d2541ade4ad72e4866c5c38ff"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "counter",
          "counter_track"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "memory_psi",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "memory_module/process_memory",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/memory_module/process_memory.sql",
      "sha256": "e25aa9e5f2a7055e44b7180befbf5a22940d5d006d9d8667290bc1580acb4410",
      "signal_patterns": [
        "%RSS%",
        "%heap%",
        "%mem%",
        "%rss%"
      ],
      "skill_id": "memory_module",
      "source": {
        "path": "backend/skills/modules/hardware/memory_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "b987a26840357de829425e1b7deba3e412dee91d2541ade4ad72e4866c5c38ff"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "counter",
          "counter_track"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "process_memory",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "memory_module/memory_timeline",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/memory_module/memory_timeline.sql",
      "sha256": "748f47fa664c2e09ce38ef45cab008a858e6cd2a056252fe2e1bff9da281afa6",
      "signal_patterns": [
        "%MemAvailable%",
        "%MemFree%"
      ],
      "skill_id": "memory_module",
      "source": {
        "path": "backend/skills/modules/hardware/memory_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "b987a26840357de829425e1b7deba3e412dee91d2541ade4ad72e4866c5c38ff"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "counter",
          "counter_track"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "memory_timeline",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "memory_module/page_fault_analysis",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/memory_module/page_fault_analysis.sql",
      "sha256": "5f0ef537b4d5df01cec1953072936d5361a0af19998264bf020e30317117d16b",
      "signal_patterns": [
        "*fault*",
        "*page*fault*",
        "*pgfault*"
      ],
      "skill_id": "memory_module",
      "source": {
        "path": "backend/skills/modules/hardware/memory_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "b987a26840357de829425e1b7deba3e412dee91d2541ade4ad72e4866c5c38ff"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "counter",
          "counter_track"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "page_fault_analysis",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "counters"
        ]
      },
      "id": "memory_module/allocation_events",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/memory_module/allocation_events.sql",
      "sha256": "c9eaa7ea1a3058400b4599c16f1e2719af8d7266b03258ede6267e853571d9e9",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*Alloc*",
        "*alloc*",
        "*malloc*",
        "*mmap*"
      ],
      "skill_id": "memory_module",
      "source": {
        "path": "backend/skills/modules/hardware/memory_module.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "b987a26840357de829425e1b7deba3e412dee91d2541ade4ad72e4866c5c38ff"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [
          "counter",
          "counter_track"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "allocation_events",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "memory_module"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "memory_pressure_in_range/memory_pressure_analysis",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/memory_pressure_in_range/memory_pressure_analysis.sql",
      "sha256": "5b312cdd09e9c06ce511d796bd22787ef34c25e909ca70053722e9e91f8b58fb",
      "signal_patterns": [
        "%alloc_pages%",
        "%compact%",
        "%direct_reclaim%",
        "%lmkd%",
        "%lowmemory%",
        "%memory_pressure%",
        "%oom_adj%",
        "%page_alloc%",
        "%reclaim%alloc%",
        "kswapd%",
        "mem.%psi%",
        "mm_filemap_add_to_page_cache",
        "mm_filemap_delete_from_page_cache"
      ],
      "skill_id": "memory_pressure_in_range",
      "source": {
        "path": "backend/skills/atomic/memory_pressure_in_range.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "1d1b1b7b513c1ebbeb083c893261b659bc336ab81d34c49d025e7421e80a3976"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "memory_pressure_analysis",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "memory_pressure_in_range"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "memory_rss_high_watermark/rss_peaks",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/memory_rss_high_watermark/rss_peaks.sql",
      "sha256": "1852e57ce92732a62fde29779e124e98da773c2cbc573fc218e493649697e46d",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "memory_rss_high_watermark",
      "source": {
        "path": "backend/skills/atomic/memory_rss_high_watermark.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "37166099200b6eb3dfaa4d62fc6e08bb63e5baa6671f7d1a9dc8530a3a6a36b9"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "linux.memory.high_watermark"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "rss_peaks",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "process_name",
          "top_n"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "memory_rss_high_watermark"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "modem_network_correlation_summary/modem_network_correlation",
      "identity": {
        "policy": "none"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/modem_network_correlation_summary/modem_network_correlation.sql",
      "sha256": "838ec57b543a2142598650bbd6e58b0707e330af9640477a362b0bf665ef6063",
      "signal_patterns": [],
      "skill_id": "modem_network_correlation_summary",
      "source": {
        "path": "backend/skills/atomic/modem_network_correlation_summary.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "7cca2aaa1525cb329a14c22261e7c4fb8365284a7410d31bb6d9605950895a47"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.power_rails",
          "android.network_packets"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "modem_network_correlation",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts",
          "top_n"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "modem_network_correlation_summary"
}

{
  "queries": [],
  "schema_version": 1,
  "skill_id": "multi_trace_result_comparison"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "native_heap_breakdown/heap_profile_inventory",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/native_heap_breakdown/heap_profile_inventory.sql",
      "sha256": "fb4c3ddab45d6cebfd85a8ecb27e03ff43ca9daed5ceb78912aa50544e35c2a5",
      "signal_patterns": [
        "heapprofd*",
        "heapprofd_malformed_packet"
      ],
      "skill_id": "native_heap_breakdown",
      "source": {
        "path": "backend/skills/atomic/native_heap_breakdown.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "c60782edef05f79ebd9a79e7f0f8f3f2dfec35cd35c839c661f0f34a68681fff"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "callstacks.stack_profile"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "heap_profile_inventory",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/heap_target_process.sql",
            "source_sha256": "e6dc119ff332e00bd847e30c45172809b69fd93bbc3e625282be768db242c90a"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/heap_profile_scope.sql",
            "source_sha256": "ee5ac709013c98ee37aa1129e129963c8487ff5bc7a15f55ca0845981103577f"
          }
        ],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "package",
          "process_name",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "native_heap_breakdown/native_heap_hotspots",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/native_heap_breakdown/native_heap_hotspots.sql",
      "sha256": "329755f54949b0aacd8abd01ba8a27faebcfc19b893a1b282434dac0074cdac5",
      "signal_patterns": [
        "/[[]anon_shmem:dalvik-jit-code-cache]*",
        "/apex/com.android.art/*",
        "/apex/com.android.runtime/*",
        "/system/lib*/libart.so",
        "/system/lib*/libc++.so",
        "/system/lib*/libc.so"
      ],
      "skill_id": "native_heap_breakdown",
      "source": {
        "path": "backend/skills/atomic/native_heap_breakdown.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "c60782edef05f79ebd9a79e7f0f8f3f2dfec35cd35c839c661f0f34a68681fff"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "callstacks.stack_profile"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "native_heap_hotspots",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/heap_target_process.sql",
            "source_sha256": "e6dc119ff332e00bd847e30c45172809b69fd93bbc3e625282be768db242c90a"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/heap_profile_scope.sql",
            "source_sha256": "ee5ac709013c98ee37aa1129e129963c8487ff5bc7a15f55ca0845981103577f"
          }
        ],
        "name_parameters": [
          "package",
          "process_name"
        ],
        "parameters": [
          "max_rows",
          "min_alloc_mb",
          "min_size_mb",
          "package",
          "process_name",
          "upid"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "native_heap_breakdown"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "navigation_analysis/check_lifecycle_data",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/navigation_analysis/check_lifecycle_data.sql",
      "sha256": "328a77c976b3022cbdc298cd2e093db9658042e15a67d71375b0951620e27e47",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*activityResume*",
        "*activityStart*",
        "*performCreate*",
        "*performDestroy*",
        "*performPause*",
        "*performResume*",
        "*performStart*",
        "*performStop*"
      ],
      "skill_id": "navigation_analysis",
      "source": {
        "path": "backend/skills/composite/navigation_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "c8bbe81d2a904151402e873ca39bfb964e77a0287f268961fbb540b88648da48"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "check_lifecycle_data",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "navigation_analysis/get_process",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/navigation_analysis/get_process.sql",
      "sha256": "786566ac0226d3c29a0c8dfb6c6614027288a6e015f74a4eb17b4048d17d3744",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "*activityResume*",
        "*activityStart*",
        "*performCreate*",
        "*performResume*",
        "*performStart*"
      ],
      "skill_id": "navigation_analysis",
      "source": {
        "path": "backend/skills/composite/navigation_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "c8bbe81d2a904151402e873ca39bfb964e77a0287f268961fbb540b88648da48"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "get_process",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "navigation_analysis/navigation_overview",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/navigation_analysis/navigation_overview.sql",
      "sha256": "3f14e64b79b966217c4aed57db508960374b00a0a7eefb9850cc1928c5802ef0",
      "signal_patterns": [
        "${target_process.data[0].process_name}",
        "*activityResume*",
        "*activityStart*",
        "*performCreate*",
        "*performDestroy*",
        "*performPause*",
        "*performResume*",
        "*performStart*",
        "*performStop*"
      ],
      "skill_id": "navigation_analysis",
      "source": {
        "path": "backend/skills/composite/navigation_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "c8bbe81d2a904151402e873ca39bfb964e77a0287f268961fbb540b88648da48"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "navigation_overview",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "nav_rating_good_ms",
          "nav_rating_severe_ms",
          "slow_navigation_ms",
          "start_ts"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "navigation_analysis/lifecycle_phase_breakdown",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/navigation_analysis/lifecycle_phase_breakdown.sql",
      "sha256": "447a1502849ab6949e2a8a625bec0a56dd2e245ab0f0d405a04d846a413b7136",
      "signal_patterns": [
        "${target_process.data[0].process_name}",
        "*activityResume*",
        "*activityStart*",
        "*performCreate*",
        "*performDestroy*",
        "*performPause*",
        "*performResume*",
        "*performStart*",
        "*performStop*"
      ],
      "skill_id": "navigation_analysis",
      "source": {
        "path": "backend/skills/composite/navigation_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "c8bbe81d2a904151402e873ca39bfb964e77a0287f268961fbb540b88648da48"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "lifecycle_phase_breakdown",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "slow_lifecycle_ms",
          "start_ts"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "navigation_analysis/lifecycle_event_detail",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/navigation_analysis/lifecycle_event_detail.sql",
      "sha256": "68fc9054f7de0801165f1d470076fd8b30499026d33a765f81fb46a3b24a8c5f",
      "signal_patterns": [
        "${target_process.data[0].process_name}",
        "*activityResume*",
        "*activityStart*",
        "*performCreate*",
        "*performDestroy*",
        "*performPause*",
        "*performResume*",
        "*performStart*",
        "*performStop*"
      ],
      "skill_id": "navigation_analysis",
      "source": {
        "path": "backend/skills/composite/navigation_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "c8bbe81d2a904151402e873ca39bfb964e77a0287f268961fbb540b88648da48"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "lifecycle_event_detail",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "oncreate_slow_ms",
          "slow_lifecycle_ms",
          "start_ts"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "navigation_analysis/navigation_blocking_ops",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/navigation_analysis/navigation_blocking_ops.sql",
      "sha256": "52b7e5cc1e46c216384a40483f0b8b05c213ee1ac5601c8bcd8814bcf6d11df5",
      "signal_patterns": [
        "${target_process.data[0].process_name}",
        "*Binder*",
        "*GC*",
        "*LayoutInflater*",
        "*SQL*",
        "*SharedPreferences*",
        "*binder*",
        "*database*",
        "*http*",
        "*inflate*",
        "*network*",
        "*okhttp*",
        "*setContentView*",
        "*sqlite*"
      ],
      "skill_id": "navigation_analysis",
      "source": {
        "path": "backend/skills/composite/navigation_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "c8bbe81d2a904151402e873ca39bfb964e77a0287f268961fbb540b88648da48"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "navigation_blocking_ops",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/file_io_slice_names.sql",
            "source_sha256": "c93482a31b7576ab8570803e1b6c9c68beaaed8a9a7eef690e385bb26ec443ed"
          },
          {
            "order": 1,
            "source_path": "backend/skills/fragments/art_gc_names.sql",
            "source_sha256": "2e50cd240ecb068815a92c13ff38fe2ea843172eece9818b3ed8bfd05f43dfd5"
          }
        ],
        "name_parameters": [],
        "parameters": [
          "binder_blocking_ms",
          "blocking_op_min_dur_ms",
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "navigation_analysis/layout_inflation",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/navigation_analysis/layout_inflation.sql",
      "sha256": "bb043d6fad5a13c599a4e58c3417f98402ac7b0dc3cf9ec8b4c050d3c7f1995a",
      "signal_patterns": [
        "${target_process.data[0].process_name}",
        "*LayoutInflater*",
        "*inflate*",
        "*setContentView*"
      ],
      "skill_id": "navigation_analysis",
      "source": {
        "path": "backend/skills/composite/navigation_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "c8bbe81d2a904151402e873ca39bfb964e77a0287f268961fbb540b88648da48"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "layout_inflation",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "navigation_analysis/fragment_transactions",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/navigation_analysis/fragment_transactions.sql",
      "sha256": "63621fc2e8a0e7ecb2de8a8614b9868cc0c4b9b1730879764a419586920085b2",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "${target_process.data[0].process_name}",
        "*Fragment*onCreate*",
        "*Fragment*onResume*",
        "*FragmentTransaction*",
        "*commit*Fragment*",
        "*performCreate*Fragment*"
      ],
      "skill_id": "navigation_analysis",
      "source": {
        "path": "backend/skills/composite/navigation_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "c8bbe81d2a904151402e873ca39bfb964e77a0287f268961fbb540b88648da48"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "fragment_transactions",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "navigation_analysis/transition_animations",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/navigation_analysis/transition_animations.sql",
      "sha256": "c6028774e5e800a2d34289c22e7c07bdc2cf0926f7f93fc986547db5020898af",
      "signal_patterns": [
        "${target_process.data[0].process_name}",
        "*ActivityTransition*",
        "*SharedElement*",
        "*Transition*",
        "*windowAnimation*"
      ],
      "skill_id": "navigation_analysis",
      "source": {
        "path": "backend/skills/composite/navigation_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "c8bbe81d2a904151402e873ca39bfb964e77a0287f268961fbb540b88648da48"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "transition_animations",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "navigation_analysis/navigation_binder_calls",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/navigation_analysis/navigation_binder_calls.sql",
      "sha256": "4b50d5c32cf1528ee4aa10e95623b64b455536db7a86d489dd0ba106b46bfef0",
      "signal_patterns": [],
      "skill_id": "navigation_analysis",
      "source": {
        "path": "backend/skills/composite/navigation_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "c8bbe81d2a904151402e873ca39bfb964e77a0287f268961fbb540b88648da48"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "navigation_binder_calls",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "navigation_analysis/first_frame_render",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/navigation_analysis/first_frame_render.sql",
      "sha256": "2555930a3255549ad78e2b086aaeb2dd6d492ea90a083a96ea74538da367c638",
      "signal_patterns": [
        "${target_process.data[0].process_name}",
        "*Choreographer#doFrame*"
      ],
      "skill_id": "navigation_analysis",
      "source": {
        "path": "backend/skills/composite/navigation_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "c8bbe81d2a904151402e873ca39bfb964e77a0287f268961fbb540b88648da48"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "first_frame_render",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [
          "target_process"
        ],
        "result_references": [
          "target_process"
        ],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "navigation_analysis/no_data_fallback",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/navigation_analysis/no_data_fallback.sql",
      "sha256": "c9102cc70620395f564eb3ec354f80532877554b0f1a0ba63588db8b165808ea",
      "signal_patterns": [],
      "skill_id": "navigation_analysis",
      "source": {
        "path": "backend/skills/composite/navigation_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "c8bbe81d2a904151402e873ca39bfb964e77a0287f268961fbb540b88648da48"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.binder"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "no_data_fallback",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "navigation_analysis"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "network_analysis/check_network_data",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/network_analysis/check_network_data.sql",
      "sha256": "28489be1b3319bd03c1af0e3ee92e32028521193ae76be0ba49f166e88161caa",
      "signal_patterns": [],
      "skill_id": "network_analysis",
      "source": {
        "path": "backend/skills/composite/network_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "b0d6f1c51fe5e8687db9cc5ec9b1df231029151ee389c92bfb42f096e1ac13e0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.network_packets"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "check_network_data",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "interface",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "network_analysis/check_network_slices",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/network_analysis/check_network_slices.sql",
      "sha256": "92f3061a180832c2159760a6c43f4024b9e04df57bd1978c99a54f6ee25253ba",
      "signal_patterns": [
        "*Connect*",
        "*DNS*",
        "*Http*",
        "*Network*",
        "*Socket*",
        "*connect*",
        "*dns*",
        "*http*",
        "*network*",
        "*socket*"
      ],
      "skill_id": "network_analysis",
      "source": {
        "path": "backend/skills/composite/network_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "b0d6f1c51fe5e8687db9cc5ec9b1df231029151ee389c92bfb42f096e1ac13e0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.network_packets"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "check_network_slices",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "network_analysis/evidence_scope",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/network_analysis/evidence_scope.sql",
      "sha256": "c835dfd4d4fbb2fa593397fa041edd172ff70ec3a0b821f1a969ea578d60ac23",
      "signal_patterns": [],
      "skill_id": "network_analysis",
      "source": {
        "path": "backend/skills/composite/network_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "b0d6f1c51fe5e8687db9cc5ec9b1df231029151ee389c92bfb42f096e1ac13e0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.network_packets"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "evidence_scope",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "network_analysis/network_overview",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/network_analysis/network_overview.sql",
      "sha256": "bd35da378cead83b61ef9b2e9c7f21cfd081d3b252a10851a78c2fa654b9541b",
      "signal_patterns": [],
      "skill_id": "network_analysis",
      "source": {
        "path": "backend/skills/composite/network_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "b0d6f1c51fe5e8687db9cc5ec9b1df231029151ee389c92bfb42f096e1ac13e0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.network_packets"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "network_overview",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "interface",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "network_analysis/traffic_by_interface",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/network_analysis/traffic_by_interface.sql",
      "sha256": "5da00ad59c5eb2283679732c32d786f5ce15b08bd9c2c14bf1971a2f1cad7fa8",
      "signal_patterns": [],
      "skill_id": "network_analysis",
      "source": {
        "path": "backend/skills/composite/network_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "b0d6f1c51fe5e8687db9cc5ec9b1df231029151ee389c92bfb42f096e1ac13e0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.network_packets"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "traffic_by_interface",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "interface",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "network_analysis/app_traffic_ranking",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/network_analysis/app_traffic_ranking.sql",
      "sha256": "1ef189aa42be50e58bef1396d6838dbdc2952213f0e228e4b550bedb670faca3",
      "signal_patterns": [],
      "skill_id": "network_analysis",
      "source": {
        "path": "backend/skills/composite/network_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "b0d6f1c51fe5e8687db9cc5ec9b1df231029151ee389c92bfb42f096e1ac13e0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.network_packets"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "app_traffic_ranking",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "interface",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "network_analysis/transport_distribution",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/network_analysis/transport_distribution.sql",
      "sha256": "fcec021159fdb55fab906af8125cb546c8aa1015898ec9415d5a8e2c3d394605",
      "signal_patterns": [],
      "skill_id": "network_analysis",
      "source": {
        "path": "backend/skills/composite/network_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "b0d6f1c51fe5e8687db9cc5ec9b1df231029151ee389c92bfb42f096e1ac13e0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.network_packets"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "transport_distribution",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "interface",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "network_analysis/port_analysis",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/network_analysis/port_analysis.sql",
      "sha256": "6be78566bc2699e15acd863e81874033aa8ab134e7595cef5cb643a953ba3cf2",
      "signal_patterns": [],
      "skill_id": "network_analysis",
      "source": {
        "path": "backend/skills/composite/network_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "b0d6f1c51fe5e8687db9cc5ec9b1df231029151ee389c92bfb42f096e1ac13e0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.network_packets"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "port_analysis",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "interface",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "network_analysis/traffic_timeline",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/network_analysis/traffic_timeline.sql",
      "sha256": "1d53bc28b531aad7a77d69ccf0fd9b5253fa3334b03cb0397780f292a7ed4f8c",
      "signal_patterns": [],
      "skill_id": "network_analysis",
      "source": {
        "path": "backend/skills/composite/network_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "b0d6f1c51fe5e8687db9cc5ec9b1df231029151ee389c92bfb42f096e1ac13e0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.network_packets"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "traffic_timeline",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "interface",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "network_analysis/large_transfers",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/network_analysis/large_transfers.sql",
      "sha256": "0f7b7c42704cc9aef6c19ad8a962a9d2fa0bb66786af6ebcefd349da161b33f6",
      "signal_patterns": [],
      "skill_id": "network_analysis",
      "source": {
        "path": "backend/skills/composite/network_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "b0d6f1c51fe5e8687db9cc5ec9b1df231029151ee389c92bfb42f096e1ac13e0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.network_packets"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "large_transfers",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "interface",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "network_analysis/network_power_cost",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/network_analysis/network_power_cost.sql",
      "sha256": "a1ffe522fafa1e3a89109f35496a599239b3ce94e73efa5cad31b313dec83316",
      "signal_patterns": [],
      "skill_id": "network_analysis",
      "source": {
        "path": "backend/skills/composite/network_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "b0d6f1c51fe5e8687db9cc5ec9b1df231029151ee389c92bfb42f096e1ac13e0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.network_packets"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "network_power_cost",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "interface",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "network_analysis/network_slice_overview",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/network_analysis/network_slice_overview.sql",
      "sha256": "176afe1a6ed9ca427b1d9072619377c1bf718458f3e3c62cb0254a5593fbcb71",
      "signal_patterns": [
        "*Connect*",
        "*DNS*",
        "*Http*",
        "*Network*",
        "*Socket*",
        "*connect*",
        "*dns*",
        "*http*",
        "*network*",
        "*socket*"
      ],
      "skill_id": "network_analysis",
      "source": {
        "path": "backend/skills/composite/network_analysis.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "b0d6f1c51fe5e8687db9cc5ec9b1df231029151ee389c92bfb42f096e1ac13e0"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.network_packets"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "network_slice_overview",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [
          "end_ts",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "network_analysis"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": []
      },
      "id": "oom_adjuster_score_timeline/oom_intervals",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/oom_adjuster_score_timeline/oom_intervals.sql",
      "sha256": "e2af22f26323966091aff3f26f1c43d118fbc1d9db93d3530e39bcdb23bfb034",
      "signal_patterns": [
        "${process_name}",
        "${process_name}:*"
      ],
      "skill_id": "oom_adjuster_score_timeline",
      "source": {
        "path": "backend/skills/atomic/oom_adjuster_score_timeline.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "ff973a5e2e8c49d1bd0d2464554603f3db5abd2068e48b2f2205d8f34559dce3"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "android.oom_adjuster"
        ],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "oom_intervals",
      "template": {
        "fragments": [],
        "name_parameters": [
          "process_name"
        ],
        "parameters": [
          "end_ts",
          "process_name",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "oom_adjuster_score_timeline"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "status": "supported"
        },
        "probe_capabilities": []
      },
      "id": "page_fault_in_range/root",
      "identity": {
        "aliases": [
          "package"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/page_fault_in_range/query.sql",
      "process_scope": {
        "binding": "effective_target_processes",
        "role": "target"
      },
      "sha256": "c6237e0c2613cba23bb44e4f30723799dbfd8363730c28e6cd5f014177e02876",
      "signal_patterns": [
        "${package}",
        "${package}:*",
        "%Binder%",
        "RenderThread"
      ],
      "skill_id": "page_fault_in_range",
      "source": {
        "path": "backend/skills/atomic/page_fault_in_range.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "80e44b0f18a17185934062a9dc4a01979301b9a5bd85636389183345322348fb"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [],
        "drops": [],
        "required_tables": [],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "root",
      "template": {
        "fragments": [
          {
            "order": 0,
            "source_path": "backend/skills/fragments/effective_target_processes.sql",
            "source_sha256": "3176b87558e516c66bdca036137bb4b0782c6a6972a6924d7f22b10b9829a5fa"
          }
        ],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "end_ts",
          "package",
          "start_ts"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": [
          "__process_scope.upid"
        ]
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "page_fault_in_range"
}

{
  "queries": [
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "pipeline_4feature_scoring/producer_thread_signature",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/pipeline_4feature_scoring/producer_thread_signature.sql",
      "sha256": "e3d452768bde45ab25e7ef0aeb5a6fbfc3d27b57ce20d37974ed037ff964dcb0",
      "signal_patterns": [
        "*Choreographer#doFrame*",
        "*Vulkan*",
        "*eglSwapBuffers*",
        "*vkQueuePresentKHR*",
        "1.io",
        "1.raster",
        "1.ui",
        "Compositor",
        "CompositorTileWorker*",
        "CrRendererMain*",
        "DrawFrame*",
        "GLThread*",
        "GameThread",
        "GodotMain*",
        "RHIThread",
        "RenderThread",
        "UnityGfx*",
        "UnityMain*",
        "VizCompositorThread*",
        "VkQueue*",
        "main",
        "mqt_js*",
        "mqt_native*"
      ],
      "skill_id": "pipeline_4feature_scoring",
      "source": {
        "path": "backend/skills/atomic/pipeline_4feature_scoring.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "2188f6c3732115b4eac2d4d5250a23f8ff912ecab084d6aabc732df5c69ccef3"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "slices.with_context",
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "thread_track",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "producer_thread_signature",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "pipeline_4feature_scoring/layer_signature",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/pipeline_4feature_scoring/layer_signature.sql",
      "sha256": "8ff87b2232668290bcf1a3459865f3d4c2cced107ea9ed16478c9b00b9c6a695",
      "signal_patterns": [
        "DrawFrame*",
        "RenderThread"
      ],
      "skill_id": "pipeline_4feature_scoring",
      "source": {
        "path": "backend/skills/atomic/pipeline_4feature_scoring.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "2188f6c3732115b4eac2d4d5250a23f8ff912ecab084d6aabc732df5c69ccef3"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "slices.with_context",
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "thread_track",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "layer_signature",
      "template": {
        "fragments": [],
        "name_parameters": [
          "package"
        ],
        "parameters": [
          "package"
        ],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "pipeline_4feature_scoring/bufferqueue_path",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/pipeline_4feature_scoring/bufferqueue_path.sql",
      "sha256": "8a302178b46d2834da3f0b2277d7950fe1baaaad37ffd3a16a6738b3b1ec4d9c",
      "signal_patterns": [
        "*ASurfaceTransaction*",
        "*BLASTBufferQueue*",
        "*applyTransaction*",
        "*lockCanvas*",
        "*queueBuffer*",
        "*unlockCanvasAndPost*",
        "*updateTexImage*"
      ],
      "skill_id": "pipeline_4feature_scoring",
      "source": {
        "path": "backend/skills/atomic/pipeline_4feature_scoring.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "2188f6c3732115b4eac2d4d5250a23f8ff912ecab084d6aabc732df5c69ccef3"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "slices.with_context",
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "thread_track",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "bufferqueue_path",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    },
    {
      "compatibility": {
        "android": {
          "28": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "29": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "30": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "31": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "32": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "33": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "34": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "35": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "36": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          },
          "37": {
            "reason": "No exact API semantic fixture; runtime capability proof required",
            "status": "capability_gated"
          }
        },
        "exact_scope": {
          "reason": "SQL has no process_scope declaration",
          "status": "unsupported"
        },
        "probe_capabilities": [
          "slices"
        ]
      },
      "id": "pipeline_4feature_scoring/extra_rhythm",
      "identity": {
        "aliases": [
          "package",
          "process_name",
          "package_name",
          "target_package",
          "app_package",
          "packageName",
          "processName"
        ],
        "minConfidence": 50,
        "policy": "verify_if_present",
        "rewriteTo": "recommended_process_name_param",
        "scope": "process"
      },
      "license": {
        "origin": "smartperfetto",
        "spdx": "AGPL-3.0-or-later"
      },
      "path": "sql/pipeline_4feature_scoring/extra_rhythm.sql",
      "sha256": "4a633a948f8dac9c974512bc2bfa51525885479f8465d73ab644cd4f0691eb65",
      "signal_patterns": [
        "*AChoreographer*",
        "*FEngineLoop*",
        "*MainLoop*",
        "*PlayerLoop*",
        "*Swappy*",
        "*SwappyVk_*",
        "*processCaptureRequest*",
        "*processCaptureResult*",
        "*releaseOutputBuffer*",
        "*setFrameRate*",
        "*setFrameRateCategory*"
      ],
      "skill_id": "pipeline_4feature_scoring",
      "source": {
        "path": "backend/skills/atomic/pipeline_4feature_scoring.skill.yaml",
        "repository": "https://github.com/Gracker/SmartPerfetto",
        "sha256": "2188f6c3732115b4eac2d4d5250a23f8ff912ecab084d6aabc732df5c69ccef3"
      },
      "sql_dependencies": {
        "creates": [],
        "declared_modules": [
          "slices.with_context",
          "android.frames.timeline"
        ],
        "drops": [],
        "required_tables": [
          "slice",
          "thread_track",
          "thread",
          "process"
        ],
        "requires": [],
        "setup_queries": []
      },
      "step_id": "extra_rhythm",
      "template": {
        "fragments": [],
        "name_parameters": [],
        "parameters": [],
        "result_dependencies": [],
        "result_references": [],
        "runtime_bindings": []
      },
      "validation": {
        "default_execution": "capability_gate_required",
        "execution_verified": false,
        "fixtures": [],
        "runtime_compatible": null,
        "semantic_verified": false,
        "static_valid": true
      }
    }
  ],
  "schema_version": 1,
  "skill_id": "pipeline_4feature_scoring"
}

{
  "queries": [],
  "schema_version": 1,
  "skill_id": "pipeline_android_pip_freeform"
}

{
  "queries": [],
  "schema_version": 1,
  "skill_id": "pipeline_android_view_mixed"
}

{
  "queries": [],
  "schema_version": 1,
  "skill_id": "pipeline_android_view_multi_window"
}

{
  "queries": [],
  "schema_version": 1,
  "skill_id": "pipeline_android_view_software"
}

{
  "queries": [],
  "schema_version": 1,
  "skill_id": "pipeline_android_view_standard_blast"
}

{
  "queries": [],
  "schema_version": 1,
  "skill_id": "pipeline_android_view_standard_legacy"
}

{
  "queries": [],
  "schema_version": 1,
  "skill_id": "pipeline_angle_gles_vulkan"
}

{
  "queries": [],
  "schema_version": 1,
  "skill_id": "pipeline_camera_pipeline"
}

{
  "queries": [],
  "schema_version": 1,
  "skill_id": "pipeline_chrome_browser_viz"
}

{
  "queries": [],
  "schema_version": 1,
  "skill_id": "pipeline_compose_standard"
}

{
  "queries": [],
  "schema_version": 1,
  "skill_id": "pipeline_flutter_surfaceview_impeller"
}

{
  "queries": [],
  "schema_version": 1,
  "skill_id": "pipeline_flutter_surfaceview_skia"
}