euthyna 0.3.1 → 0.4.0

package/.agents/skills/euthyna/SKILL.md

@@ -76,8 +76,9 @@ license: Apache-2.0
 │
 ├─ 一次变更（PR / diff / commit）────► 阶段 B：变更面审计
 │   （「这个 PR 安全吗」）               读 references/change-audit.md
-│                                       ★ diff 里有删除行 → 先跑 history
-│                                       ★ 要谈测试覆盖   → 先跑 coverage
+│                                       ★ 第一条命令：euthyna audit --base <分叉点>
+│                                         （history + deps 一次跑完，见下节）
+│                                       ★ 要谈测试覆盖   → 再跑 coverage
 │
 ├─ 一个仓库 / 依赖面 ────────────────► 阶段 A：依赖面审计
 │   （「依赖有没有问题」）               读 references/dependency-audit.md
@@ -100,10 +101,15 @@ license: Apache-2.0
 
 | 测量 | 回答的问题 | 什么时候**必须**跑 |
 |---|---|---|
-| `history` | 这次变更**删掉**的代码来自哪个提交？那个提交是不是安全修复？ | diff 里有删除行时（阶段 B） |
+| `audit` | 上面两个问题**一次跑完**（history 默认追溯最初引入者 + deps 枚举 lockfile 全部依赖），合并一份报告 | **每次审计的第一条命令**（阶段 B 开场） |
+| `history` | 这次变更**删掉**的代码来自哪个提交？那个提交是不是安全修复？ | 需要单独重跑 history 时（如换 `--base`） |
 | `coverage` | 某个符号在测试运行中**到底有没有被调用过**？ | 报告里要说「测过 / 没测过」时（阶段 B / C） |
 
 ```powershell
+# 唯一必需的参数是 --base（改前版本 / PR 分叉点）：
+node <euthyna 仓库>/bin/euthyna.js audit --base <改前版本> --repo <被审计的仓库>
+
+# history / coverage 按需单独跑：
 node <euthyna 仓库>/bin/euthyna.js history  --base <改前版本> --repo <被审计的仓库>
 node <euthyna 仓库>/bin/euthyna.js coverage --coverage <覆盖率文件绝对路径> --symbol <符号名>
 ```
@@ -206,7 +212,7 @@ node <euthyna 仓库>/bin/euthyna.js gate <报告文件> --verify --cwd <被审
 ## 交付前的自检（逐条打勾，缺一条不许说「审完了」）
 
 - [ ] 每个疑似发现都走了**完整的**阶段 C，不是「看一眼觉得是假的」
-- [ ] **diff 有删除行时跑过 `history`**；删自安全修复提交的代码已按最高风险处理
+- [ ] **跑过 `audit`（或 diff 有删除行时跑过 `history`）**；删自安全修复提交的代码已按最高风险处理
 - [ ] 报告里每句「测过 / 没测过」都有 `coverage` 输出支撑，或已标为「不可评估」
 - [ ] **退出码为 `2` 的判据没有出现在「干净」一栏**
 - [ ] 每条结论都带 `file:line`

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

@@ -14,8 +14,8 @@ CLI **不在技能目录里**，它是本项目的独立程序。按可用性从
 
 | 情况 | 怎么写 | 备注 |
 |---|---|---|
-| 已安装 | `euthyna history …` | `euthyna` 是包声明的命令名 |
-| 有本项目检出 | `node <euthyna 仓库>/bin/euthyna.js history …` | 最常用的形式 |
+| 已安装 | `euthyna audit …` | `euthyna` 是包声明的命令名 |
+| 有本项目检出 | `node <euthyna 仓库>/bin/euthyna.js audit …` | 最常用的形式 |
 | 两者都没有 | —— | **把判据标为「不可评估」**，不要手工估算顶上 |
 
 ### ⚠️ 一个真实的坑：相对路径只在 euthyna 仓库里成立
@@ -54,17 +54,21 @@ node <euthyna 仓库>/bin/euthyna.js history --base <rev> --repo <被审计的
 **只要 diff 里有删除行，就先跑它。** 这不是可选步骤：一个校验被删掉而看着「很干净」的 diff，
 正是安全回归最常见的样子，而模型无法对几百行被删代码逐行做 blame 再回溯提交历史。
 
+**通常不必单独跑它** —— `euthyna audit`（见第一节）已经把 history（默认开来源追溯）
+和 deps 一次跑完。单独跑 `history` 的场景：换一个 `--base` 重新对比、只要 history 不要 deps。
+
 ### 命令
 
 ```powershell
 # 基础：本次变更删掉的代码来自哪些提交、那些提交像不像安全修复
+# （来源追溯默认开启：删除行归属到「最初引入」该内容的提交）
 node <euthyna 仓库>/bin/euthyna.js history --base <改前版本> --repo <被审计的仓库>
 
 # 加测「曾被移除又加回来」的行（有探针上限，比基础版慢）
 node <euthyna 仓库>/bin/euthyna.js history --base <改前版本> --pickaxe --repo <被审计的仓库>
 
-# 把删除行归属到「最初引入」该内容的提交（而非 blame 的「最后修改者」，有探针上限）
-node <euthyna 仓库>/bin/euthyna.js history --base <改前版本> --origins --repo <被审计的仓库>
+# 关闭来源追溯，退回 blame 的「最后修改」语义（更快；输出会写明这一点）
+node <euthyna 仓库>/bin/euthyna.js history --base <改前版本> --no-origins --repo <被审计的仓库>
 ```
 
 `--base` 是**改前版本**（PR 的分叉点），`--head` 默认 `HEAD`。
@@ -74,13 +78,14 @@ node <euthyna 仓库>/bin/euthyna.js history --base <改前版本> --origins --r
 
 `history` 的归属和分类各有一个**写死的近似**，读输出前先知道它们：
 
-1. **归属：blame 是「最后修改」，不是「最初引入」。** 一条安全修复行如果之后被
-   格式化/重构碰过（移动、复制），blame 会把来源归到最后碰它的那个提交。
-   `--origins` 用 `git log -S <行内容>` 定位**最初引入**该内容的提交；两者不一致时
-   事实会同时写出两个提交（`detail.blameCommit` = 最后修改、`evidence.commit` =
-   最初引入），并说明「最初引入」。
-   `--origins` 只对长度 ≥ 12 字符的行做追溯（太通用的行，-S 会指向整个历史的
-   第一个提交，那不是来源）；未启用时输出会在「未评估的判据」里写明这一点。
+1. **归属：默认用 `git log -S` 追「最初引入」；blame 的「最后修改」只是回退。** 一条安全
+   修复行如果之后被格式化/重构碰过（移动、复制），blame 会把来源归到最后碰它的那个提交
+   ——追引入者正是为了不中这个招。来源追溯用 `git log -S <行内容>` 定位**最初引入**该内容
+   的提交；与 blame 不一致时，事实会同时写出两个提交（`detail.blameCommit` = 最后修改、
+   `evidence.commit` = 最初引入），并说明「最初引入」。
+   追溯只对长度 ≥ 12 字符的行做（太通用的行，-S 会指向整个历史的第一个提交，那不是来源）；
+   被追溯的行有探针上限，触顶时剩余行保留 blame 归属并在「未评估的判据」里写明；
+   `--no-origins` 显式关闭时同样在「未评估的判据」里写明用的是 blame 语义。
 2. **分类：先看提交信息，再看提交 diff，再看被删行本身。** 消息含糊
    （"update utils"）但 diff 动了危险 API、或被删行本身就是安全代码（如
    `if (!authorized) return`）时，都会标 `security`——依据写在
@@ -226,12 +231,13 @@ euthyna euthyna-coverage — 符号调用计数（只能证伪）
 
 ```
 阶段 B（变更面审计）
-  ├─ 有删除行 ──────► history             → 结果决定风险是否拉到最高
-  ├─ 涉及回归判断 ──► history --pickaxe   → 结果决定是否按「回归」处理
-  └─ 要谈测试覆盖 ──► coverage            → 只证伪；计数非零不构成证据
+  ├─ 第一条命令 ────► audit                  → history + deps 一次跑完
+  │                                          → 有删除行：结果决定风险是否拉到最高
+  ├─ 涉及回归判断 ──► history --pickaxe      → 结果决定是否按「回归」处理
+  └─ 要谈测试覆盖 ──► coverage               → 只证伪；计数非零不构成证据
 
 阶段 C（结论面验证）
-  └─ 结论依赖「测过没有」──► coverage     → 门禁 4（演示）的真假由它约束
+  └─ 结论依赖「测过没有」──► coverage        → 门禁 4（演示）的真假由它约束
 ```
 
 **产出器给的是事实，不是裁定。** 它说「这行来自一个安全修复提交」，
@@ -265,8 +271,8 @@ node <euthyna 仓库>/bin/euthyna.js gate <报告文件> --verify --cwd <被审
 
 - `history` 的分类器**偏向宽**：漏掉安全提交比多报更危险，所以它宁可把 `fix` 也报出来。
   分类结果是**线索**，提交信息要自己读。
-- `history` 的归属默认是 blame 的「最后修改」语义；要「最初引入」用 `--origins`
-  （有探针上限，且只对 ≥ 12 字符的行做追溯）。两个近似都写在本文件「归属语义」一节。
+- `history` 的归属**默认追「最初引入」**（`git log -S`，有探针上限，只对 ≥ 12 字符的行做追溯）；
+  要退回 blame 的「最后修改」语义用 `--no-origins`（更快，输出会写明）。两个近似都写在本文件「归属语义」一节。
 - `history` 只覆盖**被删除的行**。新增的代码它不管（`--pickaxe` 除外）。
 - `coverage` **只能证伪**。见上文。
 - `coverage` 依赖调用计数，**不处理动态派发、反射、字符串调用**。

package/.agents/skills/euthyna-en/SKILL.md

@@ -85,8 +85,9 @@ What did the user give?
 │
 ├─ A change (PR / diff / commit) ───────────────► Stage B: change audit
 │   ("is this PR safe")                            read references/change-audit.md
-│                                                 ★ deleted lines in the diff → run history first
-│                                                 ★ if test coverage matters   → run coverage first
+│                                                 ★ first command: euthyna audit --base <fork point>
+│                                                   (history + deps in one run, see below)
+│                                                 ★ if test coverage matters   → then run coverage
 │
 ├─ A repository / dependency surface ───────────► Stage A: dependency audit
 │   ("do the dependencies have problems")          read references/dependency-audit.md
@@ -111,10 +112,15 @@ reliably — are shipped by this skill as a zero-dependency CLI:
 
 | Measurement | Question it answers | When it is **mandatory** |
 |---|---|---|
-| `history` | Which commit does the code this change **deleted** come from? Was that commit a security fix? | when the diff has deleted lines (Stage B) |
+| `audit` | **Both questions below in one run** (history traces original introducers by default + deps enumerates every lockfile dependency), one merged report | **the first command of every audit** (opening Stage B) |
+| `history` | Which commit does the code this change **deleted** come from? Was that commit a security fix? | when re-running history alone (e.g. a different `--base`) |
 | `coverage` | Was this symbol **ever actually invoked** by a test run? | when the report claims "tested / not tested" (Stage B / C) |
 
 ```powershell
+# the only required argument is --base (pre-change revision / PR fork point):
+node <euthyna repo>/bin/euthyna.js audit --base <pre-change revision> --repo <audited repo>
+
+# history / coverage run alone when needed:
 node <euthyna repo>/bin/euthyna.js history  --base <pre-change revision> --repo <audited repo>
 node <euthyna repo>/bin/euthyna.js coverage --coverage <absolute path to coverage file> --symbol <symbol name>
 ```
@@ -229,7 +235,7 @@ adjudication, it only guarantees that a conclusion without evidence cannot leave
 ## Pre-delivery self-check (tick every item; without all of them you may not say "audit done")
 
 - [ ] Every suspected finding went through **complete** Stage C, not "looked at it and it seems false"
-- [ ] **Ran `history` when the diff has deleted lines**; code deleted from a security-fix commit handled at highest risk
+- [ ] **Ran `audit` (or `history` when the diff has deleted lines)**; code deleted from a security-fix commit handled at highest risk
 - [ ] Every "tested / not tested" sentence in the report is backed by `coverage` output, or marked "not evaluable"
 - [ ] **No criterion with exit code `2` appears in a "clean" column**
 - [ ] Every conclusion carries a `file:line`

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

@@ -14,8 +14,8 @@ The CLI is **not in the skill directory** — it is a separate program of this p
 
 | Situation | How to write it | Notes |
 |---|---|---|
-| Installed | `euthyna history …` | `euthyna` is the command name declared by the package |
-| Project checkout available | `node <euthyna repo>/bin/euthyna.js history …` | the most common form |
+| Installed | `euthyna audit …` | `euthyna` is the command name declared by the package |
+| Project checkout available | `node <euthyna repo>/bin/euthyna.js audit …` | the most common form |
 | Neither | — | **mark the criterion as "not evaluable"**; do not substitute a manual estimate |
 
 ### ⚠️ A real pitfall: relative paths only work inside the euthyna repository
@@ -54,17 +54,21 @@ Both commands were verified: run from `D:\` with `--repo` pointing at another re
 **If the diff contains deleted lines, run it first.** This is not optional: a diff that looks "very clean" because a check was deleted
 is exactly what a security regression usually looks like, and a model cannot blame hundreds of deleted lines one by one and then trace back through commit history.
 
+**Usually you do not need to run it alone** — `euthyna audit` (section 1) already runs history (with origin tracing on by default)
+and deps in one pass. Run `history` alone to compare against a different `--base`, or when you want history without deps.
+
 ### Commands
 
 ```powershell
 # basic: which commits do this change's deleted lines come from, and do those commits look like security fixes
+# (origin tracing is on by default: deleted lines are attributed to the commit that "originally introduced" the content)
 node <euthyna repo>/bin/euthyna.js history --base <pre-change revision> --repo <audited repo>
 
 # additionally check for "removed and added back" lines (has a probe cap; slower than the basic version)
 node <euthyna repo>/bin/euthyna.js history --base <pre-change revision> --pickaxe --repo <audited repo>
 
-# attribute deleted lines to the commit that "originally introduced" the content (not blame's "last modifier"; has a probe cap)
-node <euthyna repo>/bin/euthyna.js history --base <pre-change revision> --origins --repo <audited repo>
+# disable origin tracing and fall back to blame's "last modified" semantics (faster; the output states this)
+node <euthyna repo>/bin/euthyna.js history --base <pre-change revision> --no-origins --repo <audited repo>
 ```
 
 `--base` is the **pre-change revision** (the PR's fork point); `--head` defaults to `HEAD`.
@@ -74,7 +78,7 @@ When the fork point is uncertain, use the result of `git merge-base <target bran
 
 `history`'s attribution and classification each carry a **hard-coded approximation** — know them before reading the output:
 
-1. **Attribution: blame is "last modified", not "originally introduced".** If a security-fix line was later touched by formatting/refactoring (moved, copied), blame attributes the origin to the last commit that touched it. `--origins` uses `git log -S <line content>` to locate the commit that **originally introduced** the content; when the two differ, the fact writes out both commits (`detail.blameCommit` = last modified, `evidence.commit` = originally introduced) and states so. `--origins` only traces lines ≥ 12 characters long (for overly generic lines, `-S` would point at the first commit of the entire history, which is not the origin); when it is not enabled, the output states this under "criteria not evaluated".
+1. **Attribution: `git log -S` traces the "original introducer" by default; blame's "last modified" is the fallback.** If a security-fix line was later touched by formatting/refactoring (moved, copied), blame attributes the origin to the last commit that touched it — tracing the introducer exists precisely to avoid that trap. Origin tracing uses `git log -S <line content>` to locate the commit that **originally introduced** the content; when it differs from blame, the fact writes out both commits (`detail.blameCommit` = last modified, `evidence.commit` = originally introduced) and states so. Tracing applies only to lines ≥ 12 characters long (for overly generic lines, `-S` would point at the first commit of the entire history, which is not the origin); traced lines are probe-capped, and when the cap is hit the remaining lines keep their blame attribution, stated under "criteria not evaluated"; disabling it explicitly with `--no-origins` is likewise stated there.
 2. **Classification: look at the commit message first, then the commit diff, then the deleted line itself.** When the message is vague ("update utils") but the diff touches a dangerous API, or the deleted line is itself security code (e.g. `if (!authorized) return`), it is marked `security` — the basis is recorded in `detail.classificationBasis` (`message` / `diff` / `deleted-line`). The deliberately wide bias is intentional: missing a security commit is more dangerous than over-reporting.
 
 ### What the output looks like (real capture)
@@ -213,7 +217,8 @@ The difference between `2` and `0` is the essence of why this contract exists: *
 
 ```
 Stage B (change-surface audit)
-  ├─ deleted lines present ────► history            → the result decides whether risk is raised to maximum
+  ├─ first command ───────────► audit              → history + deps in one pass
+  │                                              → deleted lines present: the result decides whether risk is raised to maximum
   ├─ regression judgment ──────► history --pickaxe  → the result decides whether to treat it as a "regression"
   └─ test coverage to discuss ─► coverage           → can only falsify; a non-zero count is not evidence
 
@@ -251,7 +256,7 @@ that a conclusion without evidence is not handed over wearing the face of "estab
 ## 7. Known limits (do not use beyond them)
 
 - `history`'s classifier is **biased wide**: missing a security commit is more dangerous than over-reporting, so it would rather report `fix` too. The classification is a **lead** — read the commit message yourself.
-- `history`'s attribution defaults to blame's "last modified" semantics; use `--origins` for "originally introduced" (has a probe cap, and only traces lines ≥ 12 characters). Both approximations are documented in this file's "Attribution semantics" section.
+- `history`'s attribution **traces the "original introducer" by default** (`git log -S`, probe-capped, only lines ≥ 12 characters); to fall back to blame's "last modified" semantics use `--no-origins` (faster; the output states this). Both approximations are documented in this file's "Attribution semantics" section.
 - `history` only covers **deleted lines**. It does not handle newly added code (except with `--pickaxe`).
 - `coverage` **can only falsify**. See above.
 - `coverage` relies on invocation counts and **does not handle dynamic dispatch, reflection, or string-based calls**. Conclusions of count 0 must be discounted when such mechanisms exist.

package/README.md

@@ -10,6 +10,10 @@
 
 <p align="center">
   <a href="https://github.com/slow-stack/euthyna/actions/workflows/ci.yml"><img src="https://github.com/slow-stack/euthyna/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
+  <a href="https://www.npmjs.com/package/euthyna"><img src="https://img.shields.io/npm/v/euthyna?style=flat&color=007EC6" alt="npm version"></a>
+  <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>
@@ -53,10 +57,11 @@ Three fact producers — a zero-dependency Node CLI:
 - **`history`** — for every line a change deletes, it attributes the line to a commit
   and classifies that commit from its message, its own diff, and the deleted line's
   content (a deleted `if (!authorized)` is flagged even under a "tweaks" subject). By
-  default the attribution is blame's "last touched"; `--origins` digs for the commit
-  that *first introduced* the content with `git log -S`. If the deleted code came from
-  a security fix, that is flagged. This is git archaeology no model can do from
-  reading a diff.
+  default the attribution traces the commit that *first introduced* the content with
+  `git log -S` (`--no-origins` falls back to blame's "last touched", which is faster
+  but mis-attributes a security line later moved by a formatting commit). If the
+  deleted code came from a security fix, that is flagged. This is git archaeology no
+  model can do from reading a diff.
 - **`coverage`** — was this symbol *ever actually invoked* by a test? It has exactly two
   answers: never invoked (established), or entered but that proves nothing about any
   specific call site (unknown). **It never reports "executed"** — V8 coverage marks
@@ -163,20 +168,20 @@ replying in chat.
 
 ```sh
 npm install -g euthyna
-euthyna history --repo <path> --base main --head HEAD          # add --origins to chase the first introducer
+euthyna audit --repo <path> --base main --head HEAD            # history + deps in one run
 euthyna coverage --coverage coverage/coverage-final.json --symbol <name>
-euthyna deps --repo <path> --dep <name>
+euthyna deps --repo <path> --all                               # or --dep <name> for a single dep
 euthyna gate <adjudication-report.md> --verify --cwd <repo>    # mechanically check the six gates
 ```
 
-Or without a global install: `npx euthyna history --repo <path> --base main`.
+Or without a global install: `npx euthyna audit --repo <path> --base main`.
 
 From a checkout instead (development):
 
 ```sh
 git clone https://github.com/slow-stack/euthyna
-cd euthyna && npm test                                 # 178 tests; no install step exists
-node bin/euthyna.js history --repo <path> --base main --head HEAD
+cd euthyna && npm test                                 # 207 tests; no install step exists
+node bin/euthyna.js audit --repo <path> --base main --head HEAD
 ```
 
 What `history` reports looks like this:
@@ -191,9 +196,10 @@ What `history` reports looks like this:
 
 Every deleted line is blamed back to a commit, and the `复现`
 (Reproduce) command lets you re-derive the claim yourself without trusting the report.
-Add `--json` for the structured fact report, `--pickaxe` to detect lines that were
-removed and are now being added back, and `--origins` to attribute deleted lines to the
-commit that first introduced their content rather than to blame's last modifier.
+Add `--json` for the structured fact report and `--pickaxe` to detect lines that were
+removed and are now being added back. Origin tracing is on by default (deleted lines
+are attributed to the commit that first introduced their content); `--no-origins`
+falls back to blame's last-modifier attribution, which is faster.
 
 ### Exit codes are part of the contract
 
@@ -319,8 +325,9 @@ euthyna/
 
 ## 🧭 Status
 
-Early, and honest about it. Working: the two fact producers, the skill, the benchmark harness.
-Not yet built: wiring the skill to the CLI so an agent uses them without being told, and the
+Early, and honest about it. Working: the fact producers (`euthyna audit` runs history
+and the full dependency surface in one command — the skill documents it as the first
+command of every audit), the skill, the benchmark harness. Not yet built: the
 git-history / coverage work needed to close the remaining recall gap.
 
 The design notes are available in English and Chinese; the `-zh` files are the originals.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "euthyna",
-  "version": "0.3.1",
+  "version": "0.4.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",

package/plugin.yaml

@@ -1,5 +1,5 @@
 name: euthyna
-version: 0.3.1
+version: 0.4.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

@@ -18,7 +18,7 @@ import path from 'node:path';
 import { readFile } from 'node:fs/promises';
 import { collectHistoryFacts } from './facts/history.js';
 import { collectCoverageFacts } from './facts/coverage.js';
-import { collectDependencyFacts } from './facts/deps.js';
+import { collectDependencyFacts, listDependencies, detectManifest, manifestTypeForFile } from './facts/deps.js';
 import { parseGateReport, validateFindings, verifyFinding, renderGateReport } from './gate.js';
 import { makeReport, renderReport, safeTextLines, KIND } from './contract.js';
 import { repoToplevel, revParse } from './git.js';
@@ -49,6 +49,12 @@ const DEPS_PRODUCER = {
   purpose: '依赖锁定版本（读取 lockfile，不含漏洞判定）',
   purposeEn: 'dependency pinned versions (reads lockfiles, no vulnerability verdict)'
 };
+const AUDIT_PRODUCER = {
+  name: 'euthyna-audit',
+  version: '0.1.0',
+  purpose: '变更面审计：删除代码来源 + 依赖锁定版本，一次测量',
+  purposeEn: 'change-surface audit: deleted-code provenance + dependency pins, one run'
+};
 
 /** The producer object that goes into a report, with its purpose in the active language. */
 function producerFor(producer, lang) {
@@ -65,20 +71,23 @@ euthyna —— 给 AI 编码 agent 用的确定性事实产出器
 它不是扫描器。它只回答两个模型算不准的问题，并把答案写成带证据的事实。
 
 用法:
-  euthyna history  --base <rev> [--head <rev>] [--repo <dir>] [--pickaxe] [--origins] [--json]
+  euthyna audit    --base <rev> [--head <rev>] [--repo <dir>] [--pickaxe] [--no-origins] [--json]
+  euthyna history  --base <rev> [--head <rev>] [--repo <dir>] [--pickaxe] [--no-origins] [--json]
   euthyna coverage --coverage <file> --symbol <name> [--file <path>] [--json]
-  euthyna deps     [--repo <dir>] [--lockfile <file>] --dep <name> [--dep <name>] [--json]
+  euthyna deps     [--repo <dir>] [--lockfile <file>] (--dep <name> | --all) [--json]
   euthyna gate     <报告文件> [--verify] [--cwd <dir>] [--json]
 
 语言: 默认中文。加 --lang en 或设环境变量 EUTHYNA_LANG=en 切换英文输出。
 
 命令:
+  audit      一次跑完变更面审计：history + deps（枚举 lockfile 全部依赖），合并报告
+             这是技能文档默认推荐入口；coverage 因需要覆盖率文件和符号名不在其中
   history    本次变更删掉了哪些代码、它们分别由哪个提交引入、该提交是不是安全修复
-             --base    必填，比较的基线版本（如 main、HEAD~5、某个 commit）
-             --head    可选，默认 HEAD
-             --pickaxe 额外检查「曾被移除又加回来」的新增行（有探针上限）
-             --origins 用 git log -S 把删除行归属到「最初引入」该内容的提交，
-                       而非 blame 的「最后修改者」（有探针上限，比默认慢）
+             --base        必填，比较的基线版本（如 main、HEAD~5、某个 commit）
+             --head        可选，默认 HEAD
+             --pickaxe     额外检查「曾被移除又加回来」的新增行（有探针上限）
+             --no-origins  关闭来源追溯；默认用 git log -S 把删除行归属到「最初引入」
+                           该内容的提交（有探针上限，比纯 blame 慢）
   coverage   某个符号在测试运行中到底有没有被调用过
              --coverage  覆盖率数据文件，c8 的 coverage-final.json
              --symbol    要查询的符号名，可重复
@@ -86,7 +95,7 @@ euthyna —— 给 AI 编码 agent 用的确定性事实产出器
   deps       某个依赖在 lockfile 里被锁定/声明成什么版本（供应链声明的裁决依据）
              --repo      可选，依赖清单所在目录（默认当前目录，自动检测）
              --lockfile  可选，显式指定清单文件（支持 package-lock.json / Cargo.lock / go.mod）
-             --dep       要查询的依赖名，可重复
+             --dep       要查询的依赖名，可重复；--all 查询清单里全部依赖
              注：只报版本事实，不判「是否含漏洞」——版本到 CVE 的映射归判定层
   gate       检查一份审计报告是否符合 6 门禁契约（不测量，只核对报告的自我声明）
              <报告文件>   报告的 markdown 文件，裁定格式见技能 SKILL.md
@@ -112,31 +121,36 @@ It is not a scanner. It answers only the two questions a model cannot compute
 reliably, and writes the answers as facts with evidence.
 
 Usage:
-  euthyna history  --base <rev> [--head <rev>] [--repo <dir>] [--pickaxe] [--origins] [--json]
+  euthyna audit    --base <rev> [--head <rev>] [--repo <dir>] [--pickaxe] [--no-origins] [--json]
+  euthyna history  --base <rev> [--head <rev>] [--repo <dir>] [--pickaxe] [--no-origins] [--json]
   euthyna coverage --coverage <file> --symbol <name> [--file <path>] [--json]
-  euthyna deps     [--repo <dir>] [--lockfile <file>] --dep <name> [--dep <name>] [--json]
+  euthyna deps     [--repo <dir>] [--lockfile <file>] (--dep <name> | --all) [--json]
   euthyna gate     <report file> [--verify] [--cwd <dir>] [--json]
 
 Language: Chinese by default. Pass --lang en or set the environment variable
 EUTHYNA_LANG=en for English output.
 
 Commands:
-  history    Which lines did this change delete, which commit introduced them,
+  audit      the change-surface audit in one run: history + deps (every lockfile
+             dependency enumerated), one merged report. The default entry point
+             the skill documents; coverage stays separate (needs a coverage file
+             and symbol names only the adjudicator knows)
+  history    which lines did this change delete, which commit introduced them,
              and was that commit a security fix?
-             --base    required, the baseline revision to compare against (main, HEAD~5, a commit)
-             --head    optional, defaults to HEAD
-             --pickaxe additionally check added lines that were once removed and now return (probe-capped)
-             --origins attribute deleted lines to the commit that FIRST introduced
-                       their content with git log -S, instead of blame's last modifier
-                       (probe-capped, slower than the default)
-  coverage   Was this symbol ever actually invoked by a test run?
+             --base        required, the baseline revision to compare against
+             --head        optional, defaults to HEAD
+             --pickaxe     also check added lines that were once removed and now return (probe-capped)
+             --no-origins  disable origin tracing; by default git log -S attributes deleted
+                           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
              --symbol    symbol name(s) to query, repeatable
              --file      optional, restrict to one file
-  deps       What version does the lockfile pin or declare for a dependency? (the basis for supply-chain claims)
+  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)
-             --dep       dependency name(s) to query, repeatable
+             --dep       dependency name(s) to query, repeatable; --all queries every dependency in the manifest
              Note: reports version facts only, never "is vulnerable" — version-to-CVE mapping
              belongs to the adjudication layer
   gate       Check an audit report against the six-gate contract (no measurement; only the report's self-declared claims)
@@ -252,12 +266,15 @@ async function runHistory(flags, lang) {
     };
   }
 
+  // Origin tracing is the default (see runAudit); --no-origins opts out.
+  const origins = flags['no-origins'] !== true;
+
   const { facts, evaluated, notEvaluated, measured } = await collectHistoryFacts({
     cwd: toplevel,
     base,
     head,
     pickaxe: flags.pickaxe === true,
-    origins: flags.origins === true,
+    origins,
     lang
   });
 
@@ -318,12 +335,42 @@ async function runCoverage(flags, lang) {
 async function runDeps(flags, lang) {
   const t = T(lang);
   const cwd = path.resolve(flags.repo ? String(flags.repo) : process.cwd());
-  const deps = asArray(flags.dep).map(String);
-  const lockfile = flags.lockfile ? String(flags.lockfile) : undefined;
+  let lockfile = flags.lockfile ? String(flags.lockfile) : undefined;
+  let deps = asArray(flags.dep).map(String);
+
+  // --all: query every dependency the manifest mentions. Used by `euthyna
+  // audit`; also available directly. The manifest is located first so the
+  // names come from the same file the per-dep resolver will read.
+  if (flags.all === true) {
+    const target = lockfile
+      ? { path: path.resolve(lockfile), type: manifestTypeForFile(path.basename(path.resolve(lockfile))) }
+      : await detectManifest(cwd);
+    if (!target?.type) {
+      return {
+        exit: EXIT.UNMEASURED,
+        error: t(
+          '--all 找不到受支持的依赖清单（package-lock.json / Cargo.lock / go.mod）',
+          '--all found no supported dependency manifest (package-lock.json / Cargo.lock / go.mod)'
+        )
+      };
+    }
+    const text = await readFile(target.path, 'utf8');
+    deps = listDependencies(target.type, text);
+    lockfile = target.path;
+    if (deps.length === 0) {
+      return {
+        exit: EXIT.UNMEASURED,
+        error: t(
+          `${target.path} 中没有枚举出任何依赖`,
+          `${target.path} enumerates no dependencies`
+        )
+      };
+    }
+  }
 
   // Asking for nothing is a caller mistake, not a measurement failure.
   if (deps.length === 0) {
-    return { exit: EXIT.USAGE, error: t('deps 需要至少一个 --dep <name>', 'deps requires at least one --dep <name>') };
+    return { exit: EXIT.USAGE, error: t('deps 需要至少一个 --dep <name>（或 --all）', 'deps requires at least one --dep <name> (or --all)') };
   }
 
   const { facts, evaluated, notEvaluated, measured } = await collectDependencyFacts({
@@ -343,6 +390,109 @@ async function runDeps(flags, lang) {
 
   return { exit: measured ? EXIT.CLEAN : EXIT.UNMEASURED, report };
 }
+/**
+ * `euthyna audit` — the change-surface measurement in one command.
+ *
+ * history (deleted-code provenance) + deps (every lockfile dependency), one
+ * combined report, exit code = the worse of the two. This is the wiring the
+ * README called "not yet built": an agent loads the skill and runs ONE command
+ * instead of being told which producers to invoke in which order.
+ *
+ * coverage is deliberately not part of audit: it needs a coverage data file and
+ * symbol names only the adjudicator knows, so there is nothing honest to
+ * auto-measure there.
+ */
+async function runAudit(flags, lang) {
+  const t = T(lang);
+  const cwd = path.resolve(flags.repo ? String(flags.repo) : process.cwd());
+
+  if (!flags.base) {
+    return { exit: EXIT.USAGE, error: t('audit 需要 --base <rev>', 'audit requires --base <rev>') };
+  }
+
+  // --- history half (mirrors runHistory's repo/base/head resolution) ---
+  const toplevel = await repoToplevel(cwd);
+  if (!toplevel) {
+    return {
+      exit: EXIT.UNMEASURED,
+      report: makeReport({
+        producer: producerFor(AUDIT_PRODUCER, lang),
+        subject: { repo: cwd },
+        facts: [],
+        notEvaluated: [
+          {
+            kind: KIND.HISTORY,
+            reason: t(
+              `${cwd} 不在任何 git 仓库内，无法测量历史`,
+              `${cwd} is not inside any git repository; history cannot be measured`
+            )
+          }
+        ]
+      })
+    };
+  }
+
+  const base = await revParse(toplevel, String(flags.base));
+  if (!base) {
+    return {
+      exit: EXIT.USAGE,
+      error: t(`无法解析 --base "${flags.base}" 为一个提交`, `cannot resolve --base "${flags.base}" to a commit`)
+    };
+  }
+
+  const head = await revParse(toplevel, String(flags.head ?? 'HEAD'));
+  if (!head) {
+    return {
+      exit: EXIT.USAGE,
+      error: t(`无法解析 --head "${flags.head ?? 'HEAD'}" 为一个提交`, `cannot resolve --head "${flags.head ?? 'HEAD'}" to a commit`)
+    };
+  }
+
+  const origins = flags['no-origins'] !== true;
+  const history = await collectHistoryFacts({
+    cwd: toplevel,
+    base,
+    head,
+    pickaxe: flags.pickaxe === true,
+    origins,
+    lang
+  });
+
+  // --- deps half: measure EVERY dependency the manifest pins, not a hand-picked list ---
+  // runDeps reports "no manifest / manifest unreadable" through {error}; that is
+  // a not-evaluated criterion here, not something to swallow silently.
+  const depResult = await runDeps({ repo: toplevel, all: true }, lang);
+  const depFacts = depResult.report?.facts ?? [];
+  const depEvaluated = depResult.report?.coverage?.evaluated ?? [];
+  const depNotEvaluated = depResult.report?.coverage?.notEvaluated ?? [];
+  if (depResult.error) {
+    depNotEvaluated.push({ kind: KIND.DEPENDENCY, reason: depResult.error });
+  }
+
+  const facts = [...history.facts, ...depFacts];
+  const evaluated = [...history.evaluated, ...depEvaluated];
+  const notEvaluated = [...history.notEvaluated, ...depNotEvaluated];
+
+  const report = makeReport({
+    producer: producerFor(AUDIT_PRODUCER, lang),
+    subject: { repo: toplevel, base, head },
+    facts,
+    evaluated,
+    notEvaluated
+  });
+
+  // Exit = the worse of the two halves. A missing lockfile keeps its
+  // notEvaluated reason (missing data is not clean) but cannot fail a run the
+  // history half answered.
+  const flagged = facts.some(
+    f => (f.kind === KIND.HISTORY || f.kind === KIND.REINTRODUCTION) &&
+      f.detail && f.detail.classification === 'security'
+  );
+  const exit = !history.measured ? EXIT.UNMEASURED : flagged ? EXIT.FLAGGED : EXIT.CLEAN;
+
+  return { exit, report };
+}
+
 async function runGate(flags, positional, lang) {
   const t = T(lang);
   const file = positional[1];
@@ -501,6 +651,8 @@ export async function main(argv = process.argv.slice(2)) {
   let result;
   if (command === 'history') {
     result = await runHistory(flags, lang);
+  } else if (command === 'audit') {
+    result = await runAudit(flags, lang);
   } else if (command === 'coverage') {
     result = await runCoverage(flags, lang);
   } else if (command === 'deps') {

package/src/facts/deps.js

@@ -200,6 +200,61 @@ function typeForFile(name) {
   return SUPPORTED.find((s) => s.file === name)?.type ?? null;
 }
 
+/**
+ * Every dependency name a manifest mentions, deduplicated and sorted.
+ *
+ * Powers `euthyna audit`, which measures the whole dependency surface without
+ * anyone typing 200 `--dep` flags. Names only — version facts still come from
+ * the same resolver path a per-dep query uses, so audit adds no new parsing.
+ */
+export function listDependencies(type, text) {
+  const names = new Set();
+  if (type === 'npm') {
+    const root = JSON.parse(text);
+    for (const key of Object.keys(root.packages ?? {})) {
+      if (!key.includes('node_modules/')) continue;
+      const name = key.split('node_modules/').pop();
+      if (name) names.add(name);
+    }
+    const walk = (tree) => {
+      for (const [name, meta] of Object.entries(tree ?? {})) {
+        if (!meta || typeof meta !== 'object') continue;
+        if (meta.version) names.add(name);
+        if (meta.dependencies && typeof meta.dependencies === 'object') walk(meta.dependencies);
+      }
+    };
+    walk(root.dependencies);
+  } else if (type === 'cargo') {
+    for (const block of text.split('[[package]]')) {
+      const name = /^\s*name\s*=\s*"([^"]+)"/m.exec(block);
+      if (name) names.add(name[1]);
+    }
+  } else if (type === 'go') {
+    let inBlock = false;
+    for (const raw of text.split('\n')) {
+      const line = raw.trim();
+      if (line.startsWith('require (')) { inBlock = true; continue; }
+      if (line === ')') { inBlock = false; continue; }
+      let match = /^require\s+(\S+)\s+v[\w.+-]+/.exec(line);
+      if (!match && inBlock) match = /^(\S+)\s+v[\w.+-]+/.exec(line);
+      if (match) names.add(match[1]);
+    }
+  }
+  return [...names].sort();
+}
+
+export { SUPPORTED as SUPPORTED_MANIFESTS, UNSUPPORTED as UNSUPPORTED_MANIFESTS };
+
+/** First supported manifest found in cwd, or null: {path, type}. */
+export async function detectManifest(cwd) {
+  return (await detectIn(cwd))[0] ?? null;
+}
+
+/** Manifest type for a filename ('npm' | 'cargo' | 'go'), or null when unsupported. */
+export function manifestTypeForFile(name) {
+  return typeForFile(name);
+}
+
 async function detectIn(cwd) {
   const found = [];
   for (const spec of SUPPORTED) {

package/src/facts/history.js

@@ -187,11 +187,12 @@ export function classifySubject(subject, { securityPattern = SECURITY_PATTERN, f
  * Attribution semantics, stated explicitly because they are the point of this
  * function and easy to over-claim:
  *
- *   - blame (the default) answers "who last touched the line" — a security-fix
- *     line that a later formatting/refactor commit moved is attributed to the
- *     formatter, not the fix. `--origins` answers "who FIRST introduced the
- *     line's content" by probing `git log -S` and re-attributes the line when
- *     the introducing commit differs and classifies security or fix.
+ *   - origins (the default) answers "who FIRST introduced the line's content"
+ *     by probing `git log -S` and re-attributes the line when the introducing
+ *     commit differs and classifies security or fix. Pass origins=false for
+ *     plain blame semantics ("who last touched the line") — a security-fix line
+ *     that a later formatting commit moved is then attributed to the formatter,
+ *     not the fix, which is exactly the mis-attribution origins exists to catch.
  *   - classification looks at the commit message first, then at whether the
  *     deleted line content itself is security vocabulary, then at whether the
  *     commit's own diff touched security-vocabulary lines. All three err broad
@@ -204,8 +205,8 @@ export function classifySubject(subject, { securityPattern = SECURITY_PATTERN, f
  * @param {string} options.head
  * @param {boolean} [options.pickaxe]  also look for reintroduced lines
  * @param {number} [options.maxPickaxe] cap on pickaxe probes (reported when hit)
- * @param {boolean} [options.origins]  re-attribute deleted lines to the commit
- *                                     that first introduced their content
+ * @param {boolean} [options.origins=true] re-attribute deleted lines to the commit
+ *                                         that first introduced their content
  * @param {number} [options.maxOrigins] cap on origin probes (reported when hit)
  */
 export async function collectHistoryFacts({
@@ -214,7 +215,7 @@ export async function collectHistoryFacts({
   head = 'HEAD',
   pickaxe = false,
   maxPickaxe = 40,
-  origins = false,
+  origins = true,
   maxOrigins = 40,
   securityPattern = SECURITY_PATTERN,
   fixPattern = FIX_PATTERN,
@@ -407,9 +408,9 @@ export async function collectHistoryFacts({
       notEvaluatedEntry(
         'history-origins',
         t(
-          '未启用 --origins，删除行的归属基于 git blame 的「最后修改」语义；' +
+          '--no-origins 已关闭来源追溯，删除行的归属基于 git blame 的「最后修改」语义；' +
             '被删行本身或提交 diff 含安全关键词时仍会标为 security',
-          '--origins not enabled; deleted lines are attributed by git blame\'s "last modified" semantics; ' +
+          '--no-origins disabled origin tracing; deleted lines are attributed by git blame\'s "last modified" semantics; ' +
             'lines whose content or commit diff contains security vocabulary are still classified security'
         )
       )