DOCA Telemetry Exporter
Examples
- "Publishing counters from my DOCA app." — this is in
scope. Walk schema-then-source; do not configure DTS here.
- "BAD_STATE when I report an event." — check the lifecycle
order before changing the report call.
Instructions
Follow Loading order below. Open the tasks companion for configure /
publish / debug. Open the capabilities companion for publish
surfaces. Do not open every companion file.
Where to start: This skill assumes DOCA is already installed and
the user is doing hands-on telemetry-exporter work — emitting
structured application telemetry (counters / events) from a
DOCA-using program to an external consumer. Open
the tasks companion if the user wants to do something (configure
/ build / modify + rebuild / run / test / debug); open
the capabilities companion when the question is what can
the exporter express on this install. If the user has not installed
DOCA yet, route to doca-setup/SKILL.md first.
If the user is confused about whether they want this library or the
DOCA Telemetry Service (the receiver) — read the
exporter-vs-service rule in
the capabilities companion
before configuring anything.
This library is NOT a DOCA Core context. There is no
doca_ctx_start() for the exporter and no per-doca_devinfo
capability-query family (its doca_caps dump is a stub). The
lifecycle is schema_init → configure exporters → register
type(s) → schema_start → source_create → source_start →
report → flush → destroy.
Example questions this skill answers well
The CLASSES of telemetry-exporter questions this skill is built to
answer, each with one worked example. The agent should treat the
class as the load-bearing piece — the worked example is a single
instance.
Audience
This skill serves external developers building applications that
emit structured telemetry through DOCA Telemetry Exporter — i.e.,
users whose application code calls doca_telemetry_exporter_*
(directly in C/C++, or through FFI/bindings from another language)
to publish counters, gauges, and events from their DOCA-using
program to an external telemetry consumer. It is not for NVIDIA
developers contributing to DOCA Telemetry Exporter itself, and it
is not for users building the receiving / aggregating telemetry
service (the DOCA Telemetry Service is a separate DOCA service with
its own public guide, reached via
doca-public-knowledge-map/SKILL.md).
Language scope. DOCA Telemetry Exporter ships as a C library
with pkg-config module name doca-telemetry-exporter. The
shipped samples are written in C. C and C++ consumers are the
canonical case; the worked examples in the tasks companion assume that path.
Other-language consumers (Rust, Go, Python, …) consume the same
*.so through FFI or language-specific bindings; the skill's
contribution in that case is to keep the exporter-vs-service
distinction, the schema → source lifecycle, the transport-not-caps
discovery rule, the same-user-as-the-app permission rule, the
buffered flush-based delivery model, and the error-taxonomy
guidance language-neutral, and to route the agent to the public C
ABI as the authoritative surface that any wrapper will eventually
call.
When to load this skill
Load this skill when the user is doing hands-on DOCA Telemetry
Exporter work, in any language. Concretely:
- Defining a
doca_telemetry_exporter_schema for the events the
application will emit (field names + field types), and
registering it with the exporter BEFORE any event is published.
- Creating one or more
doca_telemetry_exporter_source instances
to represent distinct logical sources of telemetry inside the
application (e.g. one source per worker thread / per pipeline
stage).
- Picking the right publish surface — typed structured events
(
_source_report), opaque events (_source_opaque_report), the
Metrics API (counter / gauge / histogram), OTLP logs, or the
NetFlow sibling API — for what the application reports.
- Confirming the exporter's install + transport reality (there is
NO
doca_devinfo cap-query family and NO doca_caps data for
this library): doca_telemetry_exporter_check_ipc_status for
IPC liveness, _source_get_opaque_report_max_data_size for the
opaque payload bound, and the _schema_get_* config getters.
- Debugging a
DOCA_ERROR_* returned from an exporter call
(BAD_STATE lifecycle-order vs. INVALID_VALUE type/label
mismatch vs. NO_MEMORY vs. INITIALIZATION vs. UNKNOWN
backend) and the per-call status returned to the application.
- Choosing between Telemetry Exporter and an adjacent option
(
doca_log when stdout / structured-log shipping is enough; a
Prometheus client library when the user needs a non-DOCA-aware
sink; doca-comch/SKILL.md when the user
needs a real-time event subscription back INTO the app — the
exporter is publish-only / one-way).
- Designing or extending non-C bindings (Rust, Go, Python, …)
that wrap the exporter C ABI — for the exporter-vs-service
distinction, the schema → source lifecycle, the permission
policy, the buffered flush-based delivery model, and the
transport-introspection + error rules the wrapper must honor.
Do not load this skill for general DOCA orientation, install
of DOCA itself, the receiving telemetry service (the DOCA
Telemetry Service has its own public guide reachable through
doca-public-knowledge-map/SKILL.md),
or non-exporter library questions. For those, use
doca-public-knowledge-map/SKILL.md.
What this skill provides
This is a thin loader. The body keeps only the orientation
needed to pick the right next file. The substantive
exporter-specific material lives in two companion files:
- the capabilities companion — what the exporter can express on this
install: the exporter-vs-service role-split rule, the object
family (
doca_telemetry_exporter_schema → _type/_field →
_source with the schema → source lifecycle), the four publish
surfaces (typed events / opaque events / Metrics API / OTLP
logs) plus the NetFlow sibling API, the transport-not-caps
introspection rule (check_ipc_status,
_get_opaque_report_max_data_size, _schema_get_* — NO
doca_caps data, NO device cap-query), the exporter error
taxonomy (mapped onto the cross-library DOCA_ERROR_* set, with
the note that there is NO AGAIN and NO NOT_FOUND on this
surface), the observability surface (per-call status + IPC
status + file-write inspection + the receiver side as the
end-to-end signal), the safety policy that gates the
same-user-as-the-app permission and the receiver-up-first
staging, and the path-selection rule against doca_log and
doca-comch.
- the tasks companion — step-by-step workflows for the six in-scope
exporter verbs:
configure, build, modify (followed by a
rebuild), run, test, debug. Plus a Deferred task verbs block that points
out-of-scope questions at the right next skill.
The skill assumes a host where DOCA is already installed at the
standard location, the application runs as a user that can write
to the telemetry transport the exporter is configured for, and a
receiving telemetry consumer is reachable and started before the
exporter. It does not cover installing DOCA — that path goes
through doca-setup/SKILL.md — and it does
not cover configuring / operating the receiving telemetry service,
which is a separate DOCA service with its own public guide.
What this skill deliberately does not ship
This skill is agent guidance, not a samples or templates
bundle. To keep the boundary clean, it deliberately does not
contain — and pull requests should not add:
- Pre-written DOCA Telemetry Exporter application source code,
in any language. The verified exporter source code is the
shipped C samples at
/opt/mellanox/doca/samples/doca_telemetry_exporter/. The
agent's job is to route the user to those files and prescribe a
minimum-diff modification on them via the universal
modify-a-sample workflow in
doca-programming-guide/SKILL.md,
layered with the exporter-specific overrides inmodify.
- A telemetry consumer / collector / receiving service. The
DOCA Telemetry Service is a separate DOCA service with its own
public guide; routing to it goes through
doca-public-knowledge-map/SKILL.md.
This skill is about the publisher side only.
- Standalone build manifests (
meson.build, CMakeLists.txt,
Cargo.toml, …) parked inside the skill. The agent constructs
the build manifest in the user's project directory against
the user's installed DOCA, where pkg-config --modversion doca-telemetry-exporter is the source of truth.
- A
samples/, bindings/, or reference/ subtree of any
kind. A mock or incomplete artifact in this skill's tree, even
one labeled "reference", is misleading: users will read it as
buildable.
Loading order
- Read this skill first to confirm the user's question is
in scope.
- For the exporter-vs-service rule, the object family, the
schema → source lifecycle, the four publish surfaces + NetFlow,
the transport-not-caps introspection rule, the error taxonomy
(note: no
AGAIN, no NOT_FOUND), observability, the safety
policy, and the path-selection rule against doca_log / comch,
see the capabilities companion.
- For step-by-step workflows — configure, build, modify,
rebuild, run, test, debug — see the tasks companion.
Both companion files cross-link to each other,
doca-version/SKILL.md for the canonical
version-handling rules, and
doca-public-knowledge-map/SKILL.md
whenever the right answer is "look it up in the public docs or
the installed package layout" rather than "exporter-specific
guidance".
Related skills
doca-public-knowledge-map/SKILL.md —
the routing table for every public DOCA documentation source
and the on-disk layout of an installed DOCA package. The
exporter's public guide URL is
https://docs.nvidia.com/doca/sdk/DOCA-Telemetry-Exporter/index.html;
the on-disk samples live under
/opt/mellanox/doca/samples/doca_telemetry_exporter/. The
DOCA Telemetry Service (the receiver, out of scope here) is
a separate guide reachable through that same routing table.
doca-setup/SKILL.md — env preparation,
install verification, transport-side reachability checks, and
the I have no install yet path with the public NGC DOCA
container. This skill assumes its preconditions are satisfied
(in particular, the application user can write to the
telemetry transport).
doca-version/SKILL.md — canonical DOCA
version-handling rules. This skill's ## Version compatibility
cross-links the four-way match rule + detection chain and adds
the exporter-specific overlay rules.
doca-structured-tools-contract/SKILL.md —
the bundle's structured-tools precedence rule (detect / prefer
/ fall back / report). The Command appendix in
the tasks companion honors this contract.
doca-programming-guide/SKILL.md —
general DOCA programming patterns shared by every library: the
canonical pkg-config + meson build pattern, the universal
modify-a-shipped-sample first-app workflow, the universal
lifecycle, the cross-library DOCA_ERROR_* taxonomy, and the
program-side debug order. This skill layers exporter specifics
on top.
doca-comch/SKILL.md — the right primitive
when the user needs a real-time event subscription back INTO
the application (host ↔ DPU control-plane messaging). The
exporter is publish-only / one-way; this skill's
path-selection rule routes there when subscription is the
actual requirement.
doca-debug/SKILL.md — the cross-cutting
debug ladder (install / version / build / link / runtime /
program / driver). Exporter-specific debug (receiver not up,
lifecycle-order BAD_STATE, type/label INVALID_VALUE,
opaque-path-not-enabled) overlays on top of that ladder.
1---2license: Apache-2.03name: doca-telemetry-exporter4description: >5 Use this skill when the user is doing hands-on DOCA Telemetry Exporter6 programming on a host where DOCA is installed — defining a7 doca_telemetry_exporter_schema and event types, creating sources,8 picking a publish surface (typed events / opaque events / the metrics9 counter-gauge-histogram API / OTLP logs / NetFlow), walking the10 schema-then-source lifecycle, or debugging DOCA_ERROR_* failures from11 the exporter API. Trigger even when the user does not explicitly12 mention "DOCA Telemetry Exporter" or "doca_telemetry_exporter_*" —13 typical implicit phrasings include "publishing counters from my DOCA14 app", "BAD_STATE when I report an event", "consumer/DTS sees nothing15 but my report succeeded", "how do I export NetFlow/IPFIX records", or16 "should I link the exporter or the telemetry service". Refuse and17 route elsewhere for the receiving DOCA Telemetry Service (DTS), plain18 stdout logging via doca_log, or real-time event subscription back into19 the app via doca-comch — those belong to other skills.20metadata:21 source: https://skillmd.com/skills/nvidia/doca-telemetry-exporter22 author: NVIDIA <doca-feedback@nvidia.com>23 kind: library24 doca_version: "3.5"25 tags:26 - doca27 - telemetry28 - exporter29compatibility: >30 Requires DOCA SDK installed at /opt/mellanox/doca on Linux (Ubuntu31 22.04/24.04 or RHEL/SLES) with a BlueField DPU or ConnectX NIC32 attached. Reads the user's local install via `pkg-config33 doca-telemetry-exporter` and inspects34 /opt/mellanox/doca/{lib,include,samples,applications}. The validation35 steps require a live DOCA install.36---3738# DOCA Telemetry Exporter3940## Examples4142- **"Publishing counters from my DOCA app."** — this is in43 scope. Walk schema-then-source; do not configure DTS here.44- **"BAD_STATE when I report an event."** — check the lifecycle45 order before changing the report call.4647## Instructions4849Follow Loading order below. Open the tasks companion for configure /50publish / debug. Open the capabilities companion for publish51surfaces. Do not open every companion file.5253**Where to start:** This skill assumes DOCA is already installed and54the user is doing **hands-on telemetry-exporter work** — emitting55structured application telemetry (counters / events) from a56DOCA-using program to an external consumer. Open57the tasks companion if the user wants to *do* something (configure58/ build / modify + rebuild / run / test / debug); open59the capabilities companion when the question is *what can60the exporter express* on this install. If the user has not installed61DOCA yet, route to `doca-setup/SKILL.md` first.62If the user is confused about whether they want this library or the63DOCA Telemetry Service (the receiver) — read the64exporter-vs-service rule in65the capabilities companion66before configuring anything.6768> **This library is NOT a DOCA Core context.** There is no69> `doca_ctx_start()` for the exporter and no per-`doca_devinfo`70> capability-query family (its `doca_caps` dump is a stub). The71> lifecycle is `schema_init` → configure exporters → register72> type(s) → `schema_start` → `source_create` → `source_start` →73> report → flush → destroy.7475## Example questions this skill answers well7677The CLASSES of telemetry-exporter questions this skill is built to78answer, each with one worked example. The agent should treat the79*class* as the load-bearing piece — the worked example is a single80instance.8182- **"Which library do I want — the exporter or the telemetry83 service?"** — worked example: *"I want my DOCA Flow program to84 publish a per-second packets-processed counter to a downstream85 collector — which DOCA artifact do I link?"*. Answered by the86 exporter-vs-service rule in87 ## Capabilities and modes88 role-split table + the path-selection bullet, both of which name89 `doca-telemetry-exporter` as the publisher the application links90 and route the receiving / consuming side away from this skill.91- **"How do I emit my first structured event from a DOCA program?"** —92 worked example: *"emit a `packets_processed` event record from my93 DOCA Flow application"*. Answered by the schema → source94 lifecycle in95 ## Capabilities and modes96 object table + the workflow in97 ## configure +98 ## run step 3 (file-write smoke before99 bulk), starting from the `telemetry_export/` sample.100- **"Which publish surface do I want — typed events, metrics, OTLP101 logs, or NetFlow?"** — worked example: *"I want labeled102 per-interface packet counters and a bandwidth gauge"*. Answered103 by the publish-surface table in104 ## Capabilities and modes105 (that intent maps to the Metrics API — `_metrics_add_counter` /106 `_add_gauge` — and the `telemetry_export_metrics/` sample), plus107 the sample map in ## modify.108- **"My report call returns `DOCA_ERROR_BAD_STATE` — what did I109 get wrong?"** — worked example:110 *"`doca_telemetry_exporter_source_report` returns `BAD_STATE` on111 the first call"*. Answered by the `BAD_STATE` row in112 ## Error taxonomy113 (the source was never started, or an OTLP context is missing on114 write/flush) + the lifecycle order in115 ## configure. Note there is NO116 `DOCA_ERROR_AGAIN` and NO `DOCA_ERROR_NOT_FOUND` on this API.117- **"My program reports, but the DTS / collector sees nothing —118 where do I start?"** — worked example: *"my report returns119 success, but the DTS log is empty"*. Answered by the120 receiver-up-first staging in121 ## Safety policy122 + the file-write smoke and `check_ipc_status` steps in123 ## test (prove the publish half with124 file write, then confirm IPC is `CONNECTED` and the receiver125 is up).126- **"How do I confirm the exporter is installed and my transport127 is live?"** — worked example: *"is the exporter on my DOCA 3.x128 install, and is IPC to DTS actually connected?"*. Answered by129 the version-compatibility overlay in130 ## Version compatibility131 (cross-linking the detection chain in132 `doca-version/SKILL.md`) plus the honest133 introspection rule in134 ## Capabilities and modes135 (`doca_telemetry_exporter_check_ipc_status`, not a device136 cap-query).137138## Audience139140This skill serves **external developers building applications that141emit structured telemetry through DOCA Telemetry Exporter** — i.e.,142users whose application code calls `doca_telemetry_exporter_*`143(directly in C/C++, or through FFI/bindings from another language)144to publish counters, gauges, and events from their DOCA-using145program to an external telemetry consumer. It is *not* for NVIDIA146developers contributing to DOCA Telemetry Exporter itself, and it147is *not* for users building the receiving / aggregating telemetry148service (the DOCA Telemetry Service is a separate DOCA service with149its own public guide, reached via150`doca-public-knowledge-map/SKILL.md`).151152**Language scope.** DOCA Telemetry Exporter ships as a C library153with `pkg-config` module name `doca-telemetry-exporter`. The154shipped samples are written in C. C and C++ consumers are the155canonical case; the worked examples in the tasks companion assume that path.156Other-language consumers (Rust, Go, Python, …) consume the same157`*.so` through FFI or language-specific bindings; the skill's158contribution in that case is to keep the exporter-vs-service159distinction, the schema → source lifecycle, the transport-not-caps160discovery rule, the same-user-as-the-app permission rule, the161buffered flush-based delivery model, and the error-taxonomy162guidance language-neutral, and to route the agent to the public C163ABI as the authoritative surface that any wrapper will eventually164call.165166## When to load this skill167168Load this skill when the user is doing hands-on DOCA Telemetry169Exporter work, in any language. Concretely:170171- Defining a `doca_telemetry_exporter_schema` for the events the172 application will emit (field names + field types), and173 registering it with the exporter BEFORE any event is published.174- Creating one or more `doca_telemetry_exporter_source` instances175 to represent distinct logical sources of telemetry inside the176 application (e.g. one source per worker thread / per pipeline177 stage).178- Picking the right publish surface — typed structured events179 (`_source_report`), opaque events (`_source_opaque_report`), the180 Metrics API (counter / gauge / histogram), OTLP logs, or the181 NetFlow sibling API — for what the application reports.182- Confirming the exporter's install + transport reality (there is183 NO `doca_devinfo` cap-query family and NO `doca_caps` data for184 this library): `doca_telemetry_exporter_check_ipc_status` for185 IPC liveness, `_source_get_opaque_report_max_data_size` for the186 opaque payload bound, and the `_schema_get_*` config getters.187- Debugging a `DOCA_ERROR_*` returned from an exporter call188 (`BAD_STATE` lifecycle-order vs. `INVALID_VALUE` type/label189 mismatch vs. `NO_MEMORY` vs. `INITIALIZATION` vs. `UNKNOWN`190 backend) and the per-call status returned to the application.191- Choosing between Telemetry Exporter and an adjacent option192 (`doca_log` when stdout / structured-log shipping is enough; a193 Prometheus client library when the user needs a non-DOCA-aware194 sink; `doca-comch/SKILL.md` when the user195 needs a real-time event subscription back INTO the app — the196 exporter is publish-only / one-way).197- Designing or extending non-C bindings (Rust, Go, Python, …)198 that wrap the exporter C ABI — for the exporter-vs-service199 distinction, the schema → source lifecycle, the permission200 policy, the buffered flush-based delivery model, and the201 transport-introspection + error rules the wrapper must honor.202203Do **not** load this skill for general DOCA orientation, install204of DOCA itself, the receiving telemetry service (the DOCA205Telemetry Service has its own public guide reachable through206`doca-public-knowledge-map/SKILL.md`),207or non-exporter library questions. For those, use208`doca-public-knowledge-map/SKILL.md`.209210## What this skill provides211212This is a **thin loader**. The body keeps only the orientation213needed to pick the right next file. The substantive214exporter-specific material lives in two companion files:215216- the capabilities companion — what the exporter can express on this217 install: the exporter-vs-service role-split rule, the object218 family (`doca_telemetry_exporter_schema` → `_type`/`_field` →219 `_source` with the schema → source lifecycle), the four publish220 surfaces (typed events / opaque events / Metrics API / OTLP221 logs) plus the NetFlow sibling API, the transport-not-caps222 introspection rule (`check_ipc_status`,223 `_get_opaque_report_max_data_size`, `_schema_get_*` — NO224 `doca_caps` data, NO device cap-query), the exporter error225 taxonomy (mapped onto the cross-library `DOCA_ERROR_*` set, with226 the note that there is NO `AGAIN` and NO `NOT_FOUND` on this227 surface), the observability surface (per-call status + IPC228 status + file-write inspection + the receiver side as the229 end-to-end signal), the safety policy that gates the230 same-user-as-the-app permission and the receiver-up-first231 staging, and the path-selection rule against `doca_log` and232 `doca-comch`.233- the tasks companion — step-by-step workflows for the six in-scope234 exporter verbs: `configure`, `build`, `modify` (followed by a235 rebuild), `run`, `test`, `debug`. Plus a `Deferred task verbs` block that points236 out-of-scope questions at the right next skill.237238The skill assumes a host where DOCA is already installed at the239standard location, the application runs as a user that can write240to the telemetry transport the exporter is configured for, and a241receiving telemetry consumer is reachable and started before the242exporter. It does not cover installing DOCA — that path goes243through `doca-setup/SKILL.md` — and it does244not cover configuring / operating the receiving telemetry service,245which is a separate DOCA service with its own public guide.246247## What this skill deliberately does not ship248249This skill is **agent guidance**, not a samples or templates250bundle. To keep the boundary clean, it deliberately does not251contain — and pull requests should not add:252253- **Pre-written DOCA Telemetry Exporter application source code,254 in any language.** The verified exporter source code is the255 shipped C samples at256 `/opt/mellanox/doca/samples/doca_telemetry_exporter/`. The257 agent's job is to route the user to those files and prescribe a258 minimum-diff modification on them via the universal259 modify-a-sample workflow in260 `doca-programming-guide/SKILL.md`,261 layered with the exporter-specific overrides in262 ## modify.263- **A telemetry consumer / collector / receiving service.** The264 DOCA Telemetry Service is a separate DOCA service with its own265 public guide; routing to it goes through266 `doca-public-knowledge-map/SKILL.md`.267 This skill is about the publisher side only.268- **Standalone build manifests** (`meson.build`, `CMakeLists.txt`,269 `Cargo.toml`, …) parked inside the skill. The agent constructs270 the build manifest *in the user's project directory* against271 the user's installed DOCA, where `pkg-config --modversion272 doca-telemetry-exporter` is the source of truth.273- **A `samples/`, `bindings/`, or `reference/` subtree** of any274 kind. A mock or incomplete artifact in this skill's tree, even275 one labeled "reference", is misleading: users will read it as276 buildable.277278## Loading order2792801. Read this skill first to confirm the user's question is281 in scope.2822. **For the exporter-vs-service rule, the object family, the283 schema → source lifecycle, the four publish surfaces + NetFlow,284 the transport-not-caps introspection rule, the error taxonomy285 (note: no `AGAIN`, no `NOT_FOUND`), observability, the safety286 policy, and the path-selection rule against `doca_log` / comch,287 see the capabilities companion.**2883. **For step-by-step workflows — configure, build, modify,289 rebuild, run, test, debug — see the tasks companion.**290291Both companion files cross-link to each other,292`doca-version/SKILL.md` for the canonical293version-handling rules, and294`doca-public-knowledge-map/SKILL.md`295whenever the right answer is "look it up in the public docs or296the installed package layout" rather than "exporter-specific297guidance".298299## Related skills300301- `doca-public-knowledge-map/SKILL.md` —302 the routing table for every public DOCA documentation source303 and the on-disk layout of an installed DOCA package. The304 exporter's public guide URL is305 `https://docs.nvidia.com/doca/sdk/DOCA-Telemetry-Exporter/index.html`;306 the on-disk samples live under307 `/opt/mellanox/doca/samples/doca_telemetry_exporter/`. The308 DOCA Telemetry Service (the *receiver*, out of scope here) is309 a separate guide reachable through that same routing table.310- `doca-setup/SKILL.md` — env preparation,311 install verification, transport-side reachability checks, and312 the *I have no install yet* path with the public NGC DOCA313 container. This skill assumes its preconditions are satisfied314 (in particular, the application user can write to the315 telemetry transport).316- `doca-version/SKILL.md` — canonical DOCA317 version-handling rules. This skill's `## Version compatibility`318 cross-links the four-way match rule + detection chain and adds319 the exporter-specific overlay rules.320- `doca-structured-tools-contract/SKILL.md` —321 the bundle's structured-tools precedence rule (detect / prefer322 / fall back / report). The Command appendix in323 the tasks companion honors this contract.324- `doca-programming-guide/SKILL.md` —325 general DOCA programming patterns shared by every library: the326 canonical `pkg-config` + meson build pattern, the universal327 modify-a-shipped-sample first-app workflow, the universal328 lifecycle, the cross-library `DOCA_ERROR_*` taxonomy, and the329 program-side debug order. This skill layers exporter specifics330 on top.331- `doca-comch/SKILL.md` — the right primitive332 when the user needs a real-time event subscription back INTO333 the application (host ↔ DPU control-plane messaging). The334 exporter is publish-only / one-way; this skill's335 path-selection rule routes there when subscription is the336 actual requirement.337- `doca-debug/SKILL.md` — the cross-cutting338 debug ladder (install / version / build / link / runtime /339 program / driver). Exporter-specific debug (receiver not up,340 lifecycle-order `BAD_STATE`, type/label `INVALID_VALUE`,341 opaque-path-not-enabled) overlays on top of that ladder.