euthyna 0.7.0 → 0.8.0

package/.agents/skills/euthyna/references/fact-producers.md

@@ -149,13 +149,15 @@ node <euthyna 仓库>/bin/euthyna.js coverage `
 `--symbol` 可重复，一次查多个。加 `--file` 可限定到某个文件。Go profile 另需 `--source`
 （见下）。
 
-**三种覆盖率格式都读**（自动识别，无需参数）：
+**五种覆盖率格式都读**（自动识别，无需参数）：
 
 | 格式 | 来源 | 说明 |
 |---|---|---|
 | c8 / v8-to-istanbul `coverage-final.json` | JS 项目（c8 默认落在 `coverage/coverage-final.json`） | 每文件有 `fnMap` + `f`（调用计数数组） |
+| classic istanbul `coverage-final.json` | jest 默认 provider、nyc | 同样的 `fnMap` + `f`，另多一个 `hash` 字段（c8 没有 `hash`），两者走同一条代码路径 |
 | coverage.py JSON（format 3） | Python 项目（`coverage json` 产出） | 顶层 `{meta, files}`；`functions` 里「函数名 → 已执行行列表」，**无调用计数**。从未调用的函数仍在列表中且 `executed_lines` 为空 |
 | Go `-coverprofile`（文本） | Go 项目（`go test -coverprofile` 产出） | `mode:` 头 + 每区块一行 `路径:起始行.列,结束行.列 语句数 命中数`，**无函数名**。必须加 `--source <模块根目录>`：产出器读源码里的顶层 `func` 把行区间映射回函数 |
+| lcov tracefile（文本） | Rust 项目（cargo-llvm-cov / cargo-tarpaulin 产出），gcov / llvm-cov 也产这个格式 | `SF:` 开记录、`end_of_record` 收尾，`FN:<行>,<符号>` 与 `FNDA:<计数>,<符号>` 给出函数名与调用计数（**两段分开出现，不是相邻配对**）；**符号名是 mangled 的**，产出器按 Rust v0 mangling 的 `<十进制长度><名字>` 尾段锚定匹配你写的 `模块::函数` 路径，且绝不落在更长的 `<长度><名字>` 对内——查 `get` 不会答到 `cfg_3get` |
 
 Go 的产出命令（Go 目标）：
 ```bash
@@ -189,6 +191,51 @@ uv run --with coverage python -m coverage json -o <输出路径>.json
 覆盖率文件从哪来：项目自己产出就用它。项目不产出覆盖率时，**要么用项目自己的方式跑一次
 测试产出它，要么把该判据标为「不可评估」**。
 
+lcov 的产出命令（Rust 目标，本机实测）：
+
+```powershell
+# 0. llvm-cov / llvm-profdata 不在 PATH 上，先定位 rustc 自带的那一份
+$bin = (rustc --print sysroot) + "\lib\rustlib\x86_64-pc-windows-msvc\bin"
+# 1. 插桩构建 + 跑测试
+$env:RUSTFLAGS = "-C instrument-coverage"
+$env:LLVM_PROFILE_FILE = "<绝对路径>\prof\probe-%p-%m.profraw"
+cargo test
+# 2. 合并 profraw，再从测试二进制导出 lcov
+& "$bin\llvm-profdata.exe" merge -sparse <绝对路径>\prof\*.profraw -o <绝对路径>\probe.profdata
+& "$bin\llvm-cov.exe" export --format=lcov --instr-profile=<绝对路径>\probe.profdata `
+  "<target\debug\deps\<crate>-<hash>.exe>" --sources src > <绝对路径>\lcov.info
+# 3. 查询（lcov 不需要 --source：函数名就在 FN: 行里）
+node <euthyna 仓库>/bin/euthyna.js coverage `
+  --coverage <绝对路径>\lcov.info --symbol <模块::函数> --file <绝对路径>\src\lib.rs
+```
+
+> lcov 专属注意事项（在探针 crate 上实测）：
+> 1. **符号名是 mangled 的，本产出器不做 demangle**（本机没有可用的 demangler：
+>    `llvm-cov --Xdemangler` 试过 `rust` / `rustfilt` / `llvm-cxxfilt` / `c++filt`
+>    四个名字全部报 `could not find the demangler`）。匹配靠 **Rust v0 mangling**
+>    （`-C instrument-coverage` 蕴含的版本）的 `<十进制长度><名字>` 尾段编码，
+>    所以查询写 `模块::函数`（`split('::')` 后逐段匹配）。每段的名字必须从段边界起算——
+>    名字开头、mangling 自己的 `_` 分隔符之后、或已证明的 pair 边界——且绝不落在更长的
+>    pair 内部：查 `get` 不会答到 `cfg_3get`。带限定的查询是子序列判定而非路径精确判定。
+>    `nested::dup` 只命中 `6nested3dup`，裸 `dup` 会同时命中外层模块里的同名函数——
+>    每个命中各自报一条事实并带上自己的 mangled 名。已经 mangled 的查询（`_R`/`_Z` 开头）
+>    只做精确匹配，**绝不半解码**。
+> 2. **同一个文件可能有多条 `FN:` 指向同一行**（泛型单态化、闭包），这不是重复记录。
+>    一个泛型函数实例化两次就是两条事实，各自带自己的 mangled 名。
+> 3. `FN:` 行存在而 `FNDA:` 缺失时报「未评估」，**不默认成 0**——凭空造出「从未调用」
+>    是这个产出器最不能犯的方向。
+> 4. 同一 `SF:` 出现多条记录（或同名多条 `FNDA:`）时**计数求和**；求和不会把非零变零，
+>    对唯一可行动的结论（计数为 0）安全。
+> 5. 文件不在 tracefile 里报**「未评估」**（llvm-cov / gcov 只为被插桩的目标产记录，
+>    `--sources` 还会再过滤一层）——这与 c8 的「文件不在数据里 = 从未执行」刻意相反。
+> 6. 认较新的 `FNL:`/`FNA:` 编码时会**明确拒绝**而不是按猜的形状读；`SF:` 路径是绝对
+>    路径（Windows 上是带反斜杠的）。
+> 7. 规范允许的三种写法照读而不是拒掉：**注释记录**（顶格 `#`）可以在任何位置，而
+>    `geninfo --comment` **默认**在顶部写一条；**`KF:` 是 `SF:` 的同义词**；
+>    **`FN:<起>,<止>,<名>` 是 gcc 9+ 的形状**，止行丢弃但必须消费掉——否则 `14,` 会粘进
+>    符号名，把一个函数拆成「有行号无计数」和「有计数无行号」两条记录，前者随即误报未评估。
+>    缩进的 `#` 仍被拒绝。
+
 ### 输出长什么样（真实捕获，一次查询命中两种结果）
 
 ```

package/.agents/skills/euthyna-en/references/fact-producers.md

@@ -137,13 +137,15 @@ node <euthyna repo>/bin/euthyna.js coverage `
 `--symbol` is repeatable — query several at once. Add `--file` to restrict to a single file.
 Go profiles additionally need `--source` (see below).
 
-**Three coverage formats are read** (auto-detected, no parameters needed):
+**Five coverage formats are read** (auto-detected, no parameters needed):
 
 | Format | Source | Notes |
 |---|---|---|
 | c8 / v8-to-istanbul `coverage-final.json` | JS projects (c8 lands at `coverage/coverage-final.json` by default) | Per-file `fnMap` + `f` (invocation-count array) |
+| classic istanbul `coverage-final.json` | jest's default provider, nyc | The same `fnMap` + `f` plus a `hash` field (c8 has no `hash`); both resolve through the same code path |
 | coverage.py JSON (format 3) | Python projects (produced by `coverage json`) | Top-level `{meta, files}`; in `functions`, "function name → list of executed lines", **no invocation counts**. Functions never called are still in the list with empty `executed_lines` |
 | Go `-coverprofile` (text) | Go projects (produced by `go test -coverprofile`) | A `mode:` header plus one line per block (`path:startL.startC,endL.endC stmts count`), **no function names**. `--source <module root>` is required: the producer reads top-level `func` declarations in the source to map line ranges back to functions |
+| lcov tracefile (text) | Rust projects (produced by cargo-llvm-cov / cargo-tarpaulin); gcov / llvm-cov produce the format too | `SF:` opens a record, `end_of_record` closes it; `FN:<line>,<symbol>` and `FNDA:<count>,<symbol>` give a function name and its invocation count (**two separate runs, not adjacent pairs**); **the symbol names are mangled**, and the producer anchors the `module::function` path you write against the `<decimal length><name>` tail segments of Rust v0 mangling, never inside a longer `<length><name>` pair — a query for `get` does not answer for `cfg_3get` |
 
 The Go production commands (Go targets):
 
@@ -180,6 +182,33 @@ uv run --with coverage python -m coverage json -o <output path>.json
 
 Where the coverage file comes from: if the project produces one, use it. When the project does not, **either run its tests once with the project's own tooling to produce it, or mark the criterion as "not evaluable"**.
 
+The lcov production commands (Rust targets, measured on this machine):
+
+```powershell
+# 0. llvm-cov / llvm-profdata are not on PATH; locate rustc's own copies first
+$bin = (rustc --print sysroot) + "\lib\rustlib\x86_64-pc-windows-msvc\bin"
+# 1. instrumented build + run the tests
+$env:RUSTFLAGS = "-C instrument-coverage"
+$env:LLVM_PROFILE_FILE = "<absolute path>\prof\probe-%p-%m.profraw"
+cargo test
+# 2. merge the profraw files, then export lcov from the test binary
+& "$bin\llvm-profdata.exe" merge -sparse <absolute path>\prof\*.profraw -o <absolute path>\probe.profdata
+& "$bin\llvm-cov.exe" export --format=lcov --instr-profile=<absolute path>\probe.profdata `
+  "<target\debug\deps\<crate>-<hash>.exe>" --sources src > <absolute path>\lcov.info
+# 3. query (lcov needs no --source: the function names are in the FN: lines)
+node <euthyna repo>/bin/euthyna.js coverage `
+  --coverage <absolute path>\lcov.info --symbol <module::function> --file <absolute path>\src\lib.rs
+```
+
+> lcov-specific caveats (measured on a probe crate):
+> 1. **The symbol names are mangled and this producer does not demangle them** (no usable demangler on this machine: `llvm-cov --Xdemangler` was tried with `rust` / `rustfilt` / `llvm-cxxfilt` / `c++filt`, and all four report `could not find the demangler`). Matching relies on the `<decimal length><name>` tail segments of **Rust v0 mangling** (what `-C instrument-coverage` implies), so write the query as `module::function` (split on `::`, matched per segment). Each segment's name must start at a boundary — the start of the name, right after the mangling's own `_` separator, or at a proven pair boundary — and never strictly inside a longer pair: a query for `get` does not answer for `cfg_3get`. A qualified query is a subsequence test, not a path-exact one. `nested::dup` matches only `6nested3dup`, while a bare `dup` also matches the same-named function in an outer module — each hit is reported as its own fact carrying its own mangled name. An already-mangled query (starting with `_R`/`_Z`) is matched exactly and **never half-decoded**.
+> 2. **One file may carry several `FN:` lines pointing at the same line** (generic monomorphisation, closures). That is not a duplicate record. A generic function instantiated twice yields two facts, each carrying its own mangled name.
+> 3. When an `FN:` line exists and its `FNDA:` is missing, the result is "not evaluated", **never a default of 0** — inventing a "never invoked" out of thin air is the one direction this producer must not fail in.
+> 4. When one `SF:` appears in several records (or several same-named `FNDA:` lines exist), the counts are **summed**; summing can never turn a non-zero into zero, which is what keeps the only actionable conclusion (a count of 0) safe.
+> 5. A file absent from the tracefile is reported as **"not evaluated"** (llvm-cov / gcov only emit records for instrumented targets, and `--sources` filters further) — deliberately the opposite of c8's "file absent from the data = never executed".
+> 6. The newer `FNL:`/`FNA:` encoding is **explicitly refused** rather than read out of a guessed shape; `SF:` paths are absolute (backslash-separated on Windows).
+> 7. Three spellings the specification allows are read rather than refused: **comment records** (`#` in column 0) may appear anywhere, and `geninfo --comment` writes one at the top by default; **`KF:` is a synonym for `SF:`**; and **`FN:<start>,<end>,<name>`** is the shape gcc 9+ emits — the end line is discarded but must be *consumed*, or `14,` sticks to the symbol name and splits one function into a record with a line and no count plus one with a count and no line, the first of which then reports a spurious not-evaluated. An indented `#` is still refused.
+
 ### What the output looks like (real capture; one query hitting both result kinds)
 
 ```

package/README.md

@@ -14,7 +14,6 @@
   <a href="https://www.npmjs.com/package/euthyna"><img src="https://img.shields.io/npm/dm/euthyna?style=flat&color=007EC6" alt="npm downloads"></a>
   <a href="https://www.npmjs.com/package/euthyna"><img src="https://img.shields.io/npm/l/euthyna?style=flat&color=007EC6" alt="license: Apache-2.0"></a>
   <a href="https://search.sigstore.dev/?logIndex=2915999059"><img src="https://img.shields.io/badge/npm%20provenance-verified-007EC6?style=flat" alt="npm provenance verified"></a>
-  <a href="https://www.skills.sh/slow-stack/euthyna"><img src="https://skills.sh/b/slow-stack/euthyna.svg" alt="Agent skills installs"></a>
   <a href="https://awesome-dsh-plugin.com/p/slow-stack/euthyna/"><img src="https://img.shields.io/badge/DSH%20plugin-listed-blue" alt="Listed in the awesome-dsh-plugin catalog"></a>
 </p>
 
@@ -254,10 +253,18 @@ This project tries to be explicit about the difference. Current state:
   unchanged on a Go repository ([nektos/act](https://github.com/nektos/act), where the deleted
   lines of a security fix were traced back to the commit that introduced them) and on a Rust one
   ([rustls](https://github.com/rustls/rustls), whose fix range yielded 43 provenance facts).
-- **`coverage` on real output in three formats** — c8/V8 JSON, classic istanbul (jest/nyc, same
-  fnMap/f shape) and coverage.py JSON (format 3) — distinguishing all three states correctly, and
-  refusing anything that is not a recognizable coverage report instead of answering "symbol not
-  located" against it.
+- **`coverage` on real output in five formats** — c8/V8 JSON, classic istanbul (jest/nyc, same
+  fnMap/f shape), coverage.py JSON (format 3), Go's text `-coverprofile`, and lcov tracefiles
+  (`llvm-cov export --format=lcov`, which is how cargo-llvm-cov and cargo-tarpaulin emit Rust
+  coverage) — distinguishing all three
+  states correctly, and refusing anything that is not a recognizable coverage report instead of
+  answering "symbol not located" against it. The lcov path was measured against a probe crate
+  built with `-C instrument-coverage`: an uncalled function reports a count of 0, a called one
+  reports a count above it, and inlining was measured **not** to flatten a called function to 0.
+  What it cannot do is demangle — this machine has no working demangler, so a query is matched
+  against the `<byte length><name>` tail segments of the mangled name; a bare `dup` matches
+  every same-named function in the file, each reported separately, and a query never answers for
+  a function that merely contains the queried name (`get` does not match `cfg_3get`).
 - **`deps` against real manifests** — resolved versions reported with a line-level evidence
   pointer into the lockfile, and absent dependencies reported as established absences rather
   than silent skips. Verified against a populated npm v3 lockfile, a real `go.mod` (the *declared*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "euthyna",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Deterministic fact producers for security auditing: which deleted code came from a security fix, and which changed symbols no test ever executed.",
   "type": "module",
   "main": "./plugin/index.js",
@@ -57,7 +57,7 @@
     }
   },
   "peerDependencies": {
-    "@deepseek-ai/dsh-skill-filesystem": ">=0.1.2-rc.1 <0.2.0 || >=0.1.5-alpha.1 <0.2.0 || >=0.1.6-0 <0.2.0"
+    "@deepseek-ai/dsh-skill-filesystem": ">=0.1.2-rc.1 <0.2.0 || >=0.1.5-alpha.1 <0.2.0 || >=0.1.6-0 <0.2.0 || >=0.1.7-0 <0.2.0 || >=0.2.0-0 <0.2.1-0 || >=0.2.1-0 <0.3.0-0"
   },
   "peerDependenciesMeta": {
     "@deepseek-ai/dsh-skill-filesystem": {

package/plugin.yaml

@@ -1,5 +1,5 @@
 name: euthyna
-version: 0.7.0
+version: 0.8.0
 description: euthyna audit discipline — slash commands that drive the euthyna fact-producing CLI (history / coverage / deps / gate)
 license: Apache-2.0
 homepage: https://github.com/slow-stack/euthyna

package/src/cli.js

@@ -89,11 +89,12 @@ euthyna —— 给 AI 编码 agent 用的确定性事实产出器
              --no-origins  关闭来源追溯；默认用 git log -S 把删除行归属到「最初引入」
                            该内容的提交（有探针上限，比纯 blame 慢）
   coverage   某个符号在测试运行中到底有没有被调用过
-             --coverage  覆盖率数据文件，c8 的 coverage-final.json
+             --coverage  覆盖率数据文件，按形状自动识别 c8 / istanbul、
+                         coverage.py JSON、Go -coverprofile 文本、lcov tracefile
              --symbol    要查询的符号名，可重复
              --file      可选，限定到某个文件
              --source    可选，Go profile（go test -coverprofile）必需：模块根目录，
-                         用于把行区间映射回函数（profile 不含函数名）
+                         用于把行区间映射回函数（profile 不含函数名）；其余格式不需要
   deps       某个依赖在 lockfile 里被锁定/声明成什么版本（供应链声明的裁决依据）
              --repo      可选，依赖清单所在目录（默认当前目录，自动检测）
              --lockfile  可选，显式指定清单文件（支持 package-lock.json / Cargo.lock / go.mod）
@@ -146,12 +147,14 @@ Commands:
                            lines to the commit that FIRST introduced their content
                            (probe-capped, slower than plain blame)
   coverage   was this symbol ever actually invoked by a test run?
-             --coverage  the coverage data file, c8's coverage-final.json
+             --coverage  the coverage data file; identified by shape as c8 / istanbul,
+                         coverage.py JSON, a Go -coverprofile, or an lcov tracefile
              --symbol    symbol name(s) to query, repeatable
              --file      optional, restrict to one file
              --source    optional, required for Go profiles (go test -coverprofile):
                          the module root, used to map line ranges back to
-                         functions (the profile carries no function names)
+                         functions (the profile carries no function names); other
+                         formats do not need it
   deps       what version does the lockfile pin or declare for a dependency? (the basis for supply-chain claims)
              --repo      optional, directory containing the manifest (default cwd, auto-detected)
              --lockfile  optional, explicit manifest path (package-lock.json / Cargo.lock / go.mod)

package/src/facts/coverage.js

@@ -63,7 +63,7 @@ function reproduceCommand({ coverageFile, symbol, file, source }) {
 /**
  * Read a coverage report.
  *
- * Three formats are accepted, all identified by shape rather than by filename:
+ * Five formats are accepted, all identified by shape rather than by filename:
  *
  * 1. c8 / v8-to-istanbul `coverage-final.json` — per-file keys are
  *    path/all/statementMap/s/branchMap/b/fnMap/f. There is no istanbul `hash`,
@@ -88,6 +88,12 @@ function reproduceCommand({ coverageFile, symbol, file, source }) {
  *    parsed from the gofmt'd source under --source (module root). A file
  *    absent from the profile is *not* evidence of "never executed" (the
  *    package may not be in the test binary), so absence is notEvaluated.
+ * 5. lcov tracefiles (`llvm-cov export --format=lcov`, gcov `.info`,
+ *    cargo-llvm-cov) — text records, one per source file, opened by `SF:` and
+ *    closed by `end_of_record`, with `FN:<line>,<name>` / `FNDA:<count>,<name>`
+ *    pairs inside. Function names **are** present, but mangled; see
+ *    parseLcov() for how a query is aligned with them and why `--source` is
+ *    not needed on this path.
  *
  * Anything that matches none of these shapes is **not a coverage report this
  * producer can read**, and is reported as notEvaluated — never fed through the
@@ -105,6 +111,17 @@ export async function loadCoverage(coverageFile) {
     }
     return parsed;
   }
+  if (isLcovTracefile(raw)) {
+    const parsed = parseLcov(raw);
+    if (!parsed) {
+      throw new Error(
+        'the file looks like an lcov tracefile ("SF:" records closed by "end_of_record") but holds a line that is not ' +
+          'an lcov "key:value" line, a function line outside any record, an unclosed record, or an FN value that is not ' +
+          '"<line>,<name>" — refusing to interpret it as coverage'
+      );
+    }
+    return parsed;
+  }
   return JSON.parse(raw);
 }
 
@@ -249,6 +266,485 @@ export function goFunctionRanges(text) {
   return funcs;
 }
 
+/**
+ * lcov tracefiles (`llvm-cov export --format=lcov`, gcov `.info`,
+ * cargo-llvm-cov) are text records, one per source file:
+ *
+ *   SF:<source file>
+ *   FN:<line>,<mangled name>
+ *   FNDA:<count>,<mangled name>
+ *   FNF:12
+ *   FNH:11
+ *   DA:<line>,<count>
+ *   BRF:0
+ *   BRH:0
+ *   LF:52
+ *   LH:46
+ *   end_of_record
+ *
+ * Unlike a Go profile these records **do** carry function names, so a symbol
+ * query needs no source tree — but the names are mangled, which is what
+ * lcovSymbolMatches() is for.
+ *
+ * Two things this reader refuses rather than guesses:
+ *
+ *   - an `FN:` with no matching `FNDA:` is "no count", not "count 0". Defaulting
+ *     it to zero would manufacture a "never invoked" out of a missing line,
+ *     which is the one direction this producer must never get wrong.
+ *   - the newer `FNL:` / `FNA:` / `FNAB:` encodings are recognised and rejected.
+ *     No sample of them could be produced on this machine, and a function table
+ *     read out of a shape nobody has seen is the same failure
+ *     detectCoverageFormat() refuses — half a shape treated as coverage. (Their
+ *     spelling is taken from the lcov specification, not from an observed file.)
+ *
+ * Three spellings the specification allows beyond the shape measured above, and
+ * that are therefore read instead of refused:
+ *
+ *   - **comment records** (`#…` in column 0) may appear "anywhere — inside a
+ *     section or outside one" and are ignored when a tracefile is read.
+ *     `geninfo --comment` writes one at the very top by default, so refusing them
+ *     refused a whole class of real files — and, because the first line was then
+ *     not an SF/TN line, reported the file as "not valid JSON", which points the
+ *     reader at the wrong problem entirely. The `#` must be in column 0: that is
+ *     the spec's comment form, and an indented `#` stays an unaccounted-for line.
+ *   - **`KF:` is a synonym for `SF:`** — stated outright in the specification,
+ *     and lcov's own reader matches `/^[SK]F:/`.
+ *   - **`FN:<start>,<end>,<name>`**: the end line is optional and is emitted by
+ *     gcc 9+ and other recent toolchains, which puts it inside the range this
+ *     path advertises (gcov `.info` files). The end line is discarded — the fact
+ *     model is function-level and evidence quotes the start line — but it must be
+ *     *consumed*: otherwise `14,` becomes part of the symbol name, the one
+ *     function splits into two records (one with a line and no count, one with a
+ *     count and no line), and the count-less twin reads as "an FN: with no FNDA:"
+ *     and manufactures a not-evaluated for a function whose count is right there.
+ */
+function isLcovTracefile(raw) {
+  const first = String(raw)
+    .split(/\r?\n/)
+    .map(line => line.trim())
+    .find(line => line && !line.startsWith('#'));
+  return /^(SF|KF|TN):/.test(first ?? '');
+}
+
+const LCOV_ENTRY_RE = /^([A-Za-z_]+):(.*)$/;
+// FN alone takes the optional end line, mirroring lcovutil.pm's
+// /^FN:(\d+),((\d+),)?(.+)$/. FNDA keeps `<count>,<name>` — a name is free to
+// contain a comma, so letting FNDA accept the wider shape would eat the first
+// segment of such a name as an "end line" that means nothing there.
+const LCOV_FN_RE = /^(\d+),((\d+),)?(.+)$/;
+const LCOV_FNDA_RE = /^(\d+),(.+)$/;
+
+/**
+ * Parse an lcov tracefile into
+ * `{ __lcov, files: Map<path, { functions: Map<mangled, { line, count }> }> }`,
+ * or null if any line is not one this reader can account for.
+ *
+ * `count` is null when a function is declared without an FNDA line: the parser
+ * never substitutes a number for a count that is not in the file.
+ *
+ * Two records for the same `SF:` (a split tracefile, or one file instrumented
+ * twice) are merged by summing counts. Summing is the one merge that cannot
+ * turn a nonzero count into zero, and zero is the only conclusion this producer
+ * draws — so the merge is safe in exactly the direction that matters. A name
+ * whose count is missing on either side stays null.
+ *
+ * DA/BRDA/FNF/FNH/LF/LH/BRF/BRH/TN/VER are recognised and ignored: the fact
+ * model here is function-level, and refusing a file over a line we never read
+ * would refuse files that answer the query correctly.
+ */
+export function parseLcov(raw) {
+  const lines = String(raw).split(/\r?\n/);
+  const files = new Map();
+  let fnLines = null;
+  let fnda = null;
+  let currentPath = null;
+
+  const closeRecord = () => {
+    const functions = new Map();
+    for (const [symbol, line] of fnLines) {
+      functions.set(symbol, { line, count: fnda.has(symbol) ? fnda.get(symbol) : null });
+    }
+    // An FNDA without an FN still carries a count, and a count is enough to say
+    // "never invoked"; only its line is unknown.
+    for (const [symbol, count] of fnda) {
+      if (!functions.has(symbol)) functions.set(symbol, { line: null, count });
+    }
+    const previous = files.get(currentPath);
+    if (previous) {
+      for (const [symbol, fn] of functions) {
+        const prev = previous.functions.get(symbol);
+        if (!prev) {
+          previous.functions.set(symbol, fn);
+          continue;
+        }
+        previous.functions.set(symbol, {
+          line: prev.line ?? fn.line,
+          count: prev.count === null || fn.count === null ? null : prev.count + fn.count
+        });
+      }
+    } else {
+      files.set(currentPath, { functions });
+    }
+    fnLines = null;
+    fnda = null;
+    currentPath = null;
+  };
+
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    // Comment records are legal anywhere and mean nothing, so they are dropped
+    // before the key:value test rather than counted as an unknown key.
+    if (line.startsWith('#')) continue;
+    if (line.trim() === 'end_of_record') {
+      if (currentPath === null) return null;
+      closeRecord();
+      continue;
+    }
+    const entry = LCOV_ENTRY_RE.exec(line);
+    if (!entry) return null;
+    const [, key, value] = entry;
+
+    // `TN:` names the test run and legally precedes a record (it is also what
+    // isLcovTracefile keys on when a file has no SF line yet), so it is ignored
+    // anywhere rather than refused outside a record.
+    if (key === 'TN') continue;
+
+    // KF: is the specification's synonym for SF:, not a second record type.
+    if (key === 'SF' || key === 'KF') {
+      if (currentPath !== null) return null; // a record was never closed
+      currentPath = value;
+      fnLines = new Map();
+      fnda = new Map();
+      continue;
+    }
+    if (currentPath === null) return null; // any other key outside a record
+    if (key === 'FN') {
+      const pair = LCOV_FN_RE.exec(value);
+      if (!pair) return null;
+      // Group 2 is the end line when present; it is deliberately dropped.
+      const [, start, , , symbol] = pair;
+      if (!fnLines.has(symbol)) fnLines.set(symbol, Number(start));
+      continue;
+    }
+    if (key === 'FNDA') {
+      const pair = LCOV_FNDA_RE.exec(value);
+      if (!pair) return null;
+      const [, count, symbol] = pair;
+      fnda.set(symbol, (fnda.get(symbol) ?? 0) + Number(count));
+      continue;
+    }
+    if (key === 'FNL' || key === 'FNA' || key === 'FNAB') return null;
+  }
+
+  if (currentPath !== null) return null; // unclosed record at end of file
+  if (files.size === 0) return null; // no SF: record at all
+  return { __lcov: true, files };
+}
+
+/**
+ * The needle for one query segment: Rust's v0 mangling and Itanium both
+ * encode an identifier as `<decimal length><the identifier>`, so `dup` is
+ * looked up as `3dup`.
+ */
+export function lcovSymbolNeedle(segments) {
+  return segments.map(segment => `${Buffer.byteLength(segment, 'utf8')}${segment}`).join('');
+}
+
+/**
+ * True when `name.slice(k, end)` is a complete `<length><value>` pair — the
+ * proof that `end` is where a fresh path segment begins.
+ */
+function lcovPairEndsAt(name, end) {
+  for (let k = 0; k < end; k++) {
+    if (!/\d/.test(name[k])) continue;
+    if (k > 0 && /\d/.test(name[k - 1])) continue; // only the start of a digit run
+    let digits = k;
+    while (digits < end && /\d/.test(name[digits])) digits++;
+    if (digits >= end) continue;
+    if (digits + Number(name.slice(k, digits)) === end) return true;
+  }
+  return false;
+}
+
+/**
+ * True when the identifier `name.slice(idStart, idEnd)` sits strictly inside a
+ * longer, complete `<length><value>` pair — a reading of the name in which the
+ * identifier is part of a *longer* one, so a needle landing there is not
+ * standing at a segment boundary.
+ *
+ * Measured, and the reason this exists: in
+ * `_RNvCsi8SMnIpCoEi_13collide_probe8cfg_3get` the character before `3get` is
+ * `_`, which the separator rule accepts, but `8cfg_3get` is itself a complete
+ * pair (`8` is the length of `cfg_3get`), so `3get` is inside an identifier and
+ * a query for `get` must not answer for it.
+ */
+function lcovInsideLongerPair(name, idStart, idEnd) {
+  for (let k = 0; k < idStart; k++) {
+    if (!/\d/.test(name[k])) continue;
+    if (k > 0 && /\d/.test(name[k - 1])) continue; // only the start of a digit run
+    let digits = k;
+    while (digits < name.length && /\d/.test(name[digits])) digits++;
+    if (digits >= name.length) continue;
+    const start = digits;
+    const end = start + Number(name.slice(k, digits));
+    if (start >= idEnd || end > name.length) continue;
+    if (start < idStart && end >= idEnd) return true;
+  }
+  return false;
+}
+
+/**
+ * Does a mangled name answer for the query path `segments`?
+ *
+ * `true` when every segment appears, in order, each one anchored: at the start
+ * of the name, right after the mangling's own separators (`_`, as in
+ * `NtB2_7Counter4bump`), or at a proven `<length><value>` pair boundary — and
+ * not strictly inside a longer pair (see lcovInsideLongerPair). The segments are
+ * matched independently rather than as one concatenated needle because a
+ * mangling may insert both a disambiguator and further path components between
+ * them: a `#[cfg(test)]` module comes out as `...5testss_14exercises_some`, and
+ * the path of a trait method carries its `Self` type
+ * (`NtB4_4GearNtB4_6Widget5label`), so a concatenated needle would miss both
+ * `tests::exercises_some` and `Gear::label` outright — measured, by running the
+ * contiguous form against the real tracefiles.
+ *
+ * What this buys: the digits before an identifier are its *byte* length, so
+ * requiring the digits to be there, and to be a real length prefix, is what
+ * keeps a query for `dup` from matching a function whose own name merely ends
+ * with those characters (`7xyz3dup` is one segment, and the character before
+ * `3dup` is `z`, which proves no pair ends there).
+ *
+ * The boundary test's fourth alternative — any character outside `[A-Za-z0-9_]`
+ * — is broader than anything measured needs: every character of the 15 `FN:`
+ * symbols in the probe tracefile is inside that class, so the mangling's own
+ * `_` separator and the length prefixes are the only boundaries the measurement
+ * actually exercises. It stays permissive on purpose: the observed names give no
+ * reason to narrow it, and a narrower rule invented without the mangling's
+ * grammar could reject a legal boundary it cannot recognise.
+ *
+ * One residual over-inclusion, recorded rather than hidden: a *qualified* query
+ * is a subsequence test, not a path-exact one, so `lcov_probe::dup` also
+ * answers for `lcov_probe::nested::dup`. Each fact names the symbol it is about
+ * (see collectLcovCoverageFacts), so the reader can tell them apart; narrowing
+ * the match further would need the mangling's grammar.
+ *
+ * A query that is already mangled (`_R`/`_Z`) is matched exactly and never
+ * decoded: this producer has no demangler, and half-decoding one would be a
+ * guess about which symbol was asked for.
+ */
+export function lcovSymbolMatches(segments, name) {
+  if (segments.length === 0) return false;
+  if (segments.length === 1 && /^_[RZ]/.test(segments[0])) return name === segments[0];
+
+  let from = 0;
+  for (const segment of segments) {
+    const needle = lcovSymbolNeedle([segment]);
+    const idDigits = String(Buffer.byteLength(segment, 'utf8')).length;
+    let found = -1;
+    for (let at = name.indexOf(needle, from); at !== -1; at = name.indexOf(needle, at + 1)) {
+      const boundary =
+        at === 0 || name[at - 1] === '_' || !/[A-Za-z0-9_]/.test(name[at - 1]) || lcovPairEndsAt(name, at);
+      if (boundary && !lcovInsideLongerPair(name, at + idDigits, at + needle.length)) {
+        found = at;
+        break;
+      }
+    }
+    if (found === -1) return false;
+    from = found + needle.length;
+  }
+  return true;
+}
+
+/**
+ * A query answered from the lcov function table.
+ *
+ * No `--source`: the tracefile carries function names, so this path answers the
+ * question Go's profile cannot answer without the source tree. The trade is
+ * that the names are mangled and the matching is done on the mangled form (see
+ * lcovSymbolMatches), and that a symbol which never made it into the
+ * instrumented build has no source-tree search to fall back on — it comes out
+ * as "not located" (unknown), never as clean.
+ */
+async function collectLcovCoverageFacts({ coverage, coverageFile, targets, lang }) {
+  const t = T(lang);
+  const facts = [];
+  const evaluated = [];
+  const notEvaluated = [];
+  let counter = 0;
+
+  const entries = [...coverage.files.entries()];
+
+  if (!entries.some(([, record]) => record.functions.size > 0)) {
+    // Line coverage cannot answer a symbol question: which lines belong to a
+    // function is in the source, not in the tracefile.
+    notEvaluated.push(
+      notEvaluatedEntry(
+        KIND.TEST_COVERAGE,
+        t(
+          'lcov tracefile 里没有任何 FN: 行 —— 只有文件与行数据，没有函数名。符号级问题（这个符号被调用过吗）' +
+            '需要 FN:/FNDA: 记录才能回答，行覆盖回答不了它',
+          'The lcov tracefile carries no FN: lines — file and line records only, no function names. ' +
+            'A symbol-level question (was this symbol invoked) needs FN:/FNDA: records; line coverage cannot answer it'
+        )
+      )
+    );
+    return { facts, evaluated, notEvaluated, measured: false };
+  }
+
+  if (targets.length === 0) {
+    notEvaluated.push(
+      notEvaluatedEntry(
+        KIND.TEST_COVERAGE,
+        t(
+          '没有指定要查询的符号（--symbol）',
+          'No symbol was given to look up (--symbol)'
+        )
+      )
+    );
+    return { facts, evaluated, notEvaluated, measured: false };
+  }
+
+  for (const target of targets) {
+    const scoped = target.file
+      ? entries.filter(([entryPath]) => matchesTarget(entryPath, target.file))
+      : entries;
+
+    if (target.file && scoped.length === 0) {
+      // Deliberately the opposite of the c8 path above: a c8 report lists the
+      // files it instrumented, so absence there means "not loaded", while
+      // llvm-cov and gcov emit records only for what was instrumented and
+      // --sources filters further — absence here proves nothing about execution.
+      notEvaluated.push(
+        notEvaluatedEntry(
+          KIND.TEST_COVERAGE,
+          t(
+            `${target.file} 没有出现在 lcov tracefile 中 —— llvm-cov/gcov 只为被插桩的目标产记录（--sources 还会再过滤一层），` +
+              '所以「未出现」不能当「未执行」',
+            `${target.file} does not appear in the lcov tracefile — llvm-cov/gcov emit a record only for what was instrumented ` +
+              '(and --sources filters further), so "absent" cannot be read as "never executed"'
+          )
+        )
+      );
+      continue;
+    }
+
+    const segments = target.symbol
+      .split('::')
+      .map(segment => segment.trim())
+      .filter(Boolean);
+    const matches = [];
+    for (const [entryPath, record] of scoped) {
+      for (const [mangled, fn] of record.functions) {
+        if (lcovSymbolMatches(segments, mangled)) matches.push({ entryPath, mangled, ...fn });
+      }
+    }
+
+    if (matches.length === 0) {
+      const needle = lcovSymbolNeedle(segments);
+      facts.push(
+        makeFact({
+          id: `coverage-${++counter}`,
+          kind: KIND.TEST_COVERAGE,
+          statement:
+            t(
+              `未能在覆盖率数据中定位符号 ${target.symbol}`,
+              `Could not locate symbol ${target.symbol} in the coverage data`
+            ) +
+            (target.file ? t(`（限定文件 ${target.file}）`, ` (restricted to file ${target.file})`) : '') +
+            t(
+              ` —— lcov 的 FN: 名是 mangled 的，本产出器按段边界匹配 "${needle}"；` +
+                '泛型实例、被内联的克隆，或写法不同的路径（crate:: 前缀、以 . 分隔）都可能匹配不上，' +
+                '也可能是它根本没被编译进这次插桩构建',
+              ` — lcov FN: names are mangled and this producer matches them by segment boundaries against "${needle}"; ` +
+                'a generic instantiation, an inlined clone, or a differently spelled path (a crate:: prefix, a "." separator) may fail to match, ' +
+                'and the symbol may simply not have been compiled into this instrumented build'
+            ),
+          status: STATUS.UNKNOWN,
+          evidence: { file: target.file ?? t('(未限定文件)', '(unrestricted file)') },
+          method: 'static',
+          detail: { symbol: target.symbol, reason: 'symbol_not_located_in_fnmap' }
+        })
+      );
+      continue;
+    }
+
+    // A query can legitimately hit several symbols — a bare name repeated in two
+    // modules, or one generic function instantiated twice at the same line. Each
+    // is reported on its own so no fact claims more than the symbol it names: a
+    // bare name is a symbol name and can be stated as given, while a `::` path is
+    // a pattern, so the statement names the symbol the match actually resolved to.
+    const pathQuery = segments.length > 1;
+    for (const hit of matches) {
+      const subject = pathQuery ? hit.mangled : target.symbol;
+      const qualifier = matches.length > 1 && !pathQuery
+        ? t(
+            `（本次查询匹配到 ${matches.length} 个符号；本事实针对 ${hit.mangled}）`,
+            ` (${matches.length} symbols matched this query; this fact is about ${hit.mangled})`
+          )
+        : '';
+
+      if (hit.count === null) {
+        notEvaluated.push(
+          notEvaluatedEntry(
+            KIND.TEST_COVERAGE,
+            t(
+              `${hit.mangled} 在 tracefile 里有 FN: 行却没有任何 FNDA: 计数 —— 缺失的计数不是 0，这条记录答不了` +
+                `「${subject} 是否被调用过」`,
+              `${hit.mangled} has an FN: line in the tracefile but no FNDA: count at all — a missing count is not a zero, ` +
+                `so this record cannot answer whether ${subject} was invoked`
+            )
+          )
+        );
+        continue;
+      }
+
+      const zero = hit.count === 0;
+      facts.push(
+        makeFact({
+          id: `coverage-${++counter}`,
+          kind: KIND.TEST_COVERAGE,
+          statement: zero
+            ? t(
+                `符号 ${subject} 在本次测试运行中一次都没有被调用（调用计数为 0）—— 任何依赖它的行为都没有被执行验证`,
+                `Symbol ${subject} was not invoked even once in this test run (invocation count 0) — ` +
+                  'no behaviour depending on it was exercised'
+              ) + qualifier
+            : t(
+                `符号 ${subject} 在本次测试运行中至少被调用过 ${hit.count} 次，但被调用**不能**证明任何特定调用点执行过 —— ` +
+                  '本事实只能证伪，不能证实',
+                `Symbol ${subject} was invoked at least ${hit.count} time(s) in this test run, but being invoked ` +
+                  '**cannot** prove that any particular call site executed — this fact can refute, not confirm'
+              ) + qualifier,
+          status: zero ? STATUS.ESTABLISHED : STATUS.UNKNOWN,
+          evidence: hit.line === null ? { file: hit.entryPath } : { file: hit.entryPath, line: hit.line },
+          method: 'command',
+          command: reproduceCommand({ coverageFile, symbol: target.symbol, file: hit.entryPath }),
+          detail: {
+            symbol: target.symbol,
+            mangled: hit.mangled,
+            invocationCount: hit.count,
+            reason: zero ? 'invocation_count_zero' : 'nonzero_count_cannot_prove_call_site_execution'
+          }
+        })
+      );
+    }
+  }
+
+  // Same rule as the Go path: a query answered only by refusals was not answered
+  // at all, and "measured" must not let CI read that as clean.
+  const measured = facts.length > 0;
+  if (measured) {
+    evaluated.push({
+      kind: KIND.TEST_COVERAGE,
+      producer: 'euthyna-coverage',
+      format: 'lcov',
+      count: facts.length
+    });
+  }
+
+  return { facts, evaluated, notEvaluated, measured };
+}
+
 /**
  * True for coverage.py's `{"meta": {...}, "files": {...}}` shape.
  * A c8 report never has a top-level `meta` key.
@@ -273,6 +769,7 @@ function isCoveragePyReport(coverage) {
  */
 export function detectCoverageFormat(coverage) {
   if (coverage && typeof coverage === 'object' && coverage.__go) return 'go';
+  if (coverage && typeof coverage === 'object' && coverage.__lcov) return 'lcov';
   if (isCoveragePyReport(coverage)) return 'coverage.py';
 
   const entries = Object.entries(coverage).filter(([, v]) => v && typeof v === 'object');
@@ -405,6 +902,12 @@ export async function collectCoverageFacts({ coverageFile, targets = [], source,
     return collectGoCoverageFacts({ coverage, coverageFile, targets, source, lang });
   }
 
+  // lcov tracefiles carry mangled function names, so symbol location works on
+  // the function table and needs no source tree — the opposite trade from Go.
+  if (coverage.__lcov) {
+    return collectLcovCoverageFacts({ coverage, coverageFile, targets, lang });
+  }
+
   // c8: entries are the report's file keys directly.
   // coverage.py: the file entries live under `files`.
   const entries = Object.entries(isPy ? (coverage.files ?? {}) : coverage).filter(