codeblast 0.3.0 → 0.3.2

package/README.md

@@ -1,3 +1,5 @@
+**codeblast** is a deterministic code-graph CLI for TypeScript and Python repositories that tells developers and AI agents what breaks before a change is merged.
+
 <p align="center">
   <img src="assets/readme/hero.svg" width="100%" alt="codeblast — deterministic code graph: know what breaks before you merge"/>
 </p>
@@ -13,6 +15,8 @@
   <img src="https://img.shields.io/badge/license-MIT-8b949e?style=flat-square" alt="MIT"/>
 </p>
 
+## What it is
+
 **codeblast parses your repository into a deterministic code graph and answers the three most expensive questions around any code change:**
 > 🔗 **[Live interactive demo](https://alloevil.github.io/codeblast/)** — real architecture maps of tRPC / Tabby / sgp, with three-level drill-down
 
@@ -35,19 +39,47 @@ Built for humans (CLI / interactive HTML / PR comments) and for AI agents ([SKIL
       <a href="https://alloevil.github.io/codeblast/tabby-arch.html">
         <img src="assets/readme/arch-hover.png" alt="Tabby architecture map with hover highlighting: all edges into tabby-core lit up"/>
       </a>
-      <p align="center"><sub><b>Architecture map</b> — hover lights the dependency fan-in (Tabby, 60k★ · <a href="https://alloevil.github.io/codeblast/tabby-arch.html">live ↗</a>)</sub></p>
+      <p align="center"><sub><b>Architecture map</b> — hover lights the dependency fan-in (Tabby, 70k★ · <a href="https://alloevil.github.io/codeblast/tabby-arch.html">live ↗</a>)</sub></p>
     </td>
   </tr>
 </table>
 
+## Install
+
 ```bash
 npx codeblast demo            # build a graph of the current repo, run one impact query, emit the map
 npm i -g codeblast            # or install globally; needs Node ≥ 22.13 (built-in sqlite) or Bun
+                              # npm serves 0.3.1
 
 # Install as an agent skill (Claude Code, Codex, Cursor, and 14 more harnesses)
 npx skills add alloevil/codeblast
 ```
 
+### As a GitHub Action (one line)
+
+```yaml
+# .github/workflows/codeblast.yml
+name: codeblast
+on: pull_request
+permissions:
+  contents: read
+  pull-requests: write
+jobs:
+  analyze:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with: { fetch-depth: 0 }      # the analyzer compares base and head commits
+      - uses: alloevil/codeblast@v0.3.1
+```
+
+The action builds the analyzer from the ref you pinned (not from npm, which can lag),
+posts one sticky comment per PR and updates it in place, and stays silent when the diff
+has no structural change. Inputs: `base`, `head`, `repo-url`, `comment` (set to `false`
+to only produce the file); outputs: `has_comment`, `comment_path`. If you prefer to own
+the commenting step, copy [`.github/workflows-template/codeblast.yml`](.github/workflows-template/codeblast.yml)
+instead — it runs the same command with `npx`.
+
 ## Why not yet another LLM diagram tool
 
 ```
@@ -55,14 +87,18 @@ LLM diagrams:  code → model reads it → hand-drawn graph → render     graph
 codeblast:     code → deterministic tsc/AST parse → graph → project  graph = checkable facts
 ```
 
-**Every node, every edge, every claim carries `file:line` evidence** you can open and verify.
+**Every node and every static-analysis edge carries `file:line` evidence** you can open and verify (`co_change` edges put a co-commit count in that field instead of a source line; file-level nodes carry line 1).
 The LLM does exactly one job in the pipeline: giving modules human-readable names — node membership and edges always come from static analysis.
 
 ## The three queries
 
+<p align="center">
+  <img src="assets/readme/three-queries.svg" width="100%" alt="The three codeblast queries — impact: check the blast radius first; change: structural diff between two refs; archmap: module, file and symbol drill-down"/>
+</p>
+
 ```bash
 # Build the graph: auto-detects TS monorepos / Python, hash-based incremental updates
-# (full build of tRPC, 950 files, in ~20s)
+# (full build of tRPC: 957 files, 6248 nodes, 17072 edges — the sample run in SKILL.md)
 codeblast index <repo> --db graph.db
 
 # ① Impact — check the blast radius before you change anything
@@ -77,7 +113,8 @@ codeblast change <repo> main~5 main --json
 
 # ③ Architecture Map — interactive HTML: module → file → symbol drill-down,
 #    symbols link to source lines
-codeblast archmap graph.db --out arch.html --repo-url <github-url>
+codeblast archmap graph.db --out arch.html --repo-url <github-url> \
+  --site-url https://example.github.io/repo --og-image <share-image-url>
 
 # Optional: mine git co-change coupling (protocol pairs, config + consumers —
 # edges static analysis can't see)
@@ -88,19 +125,53 @@ codeblast cochange <repo> graph.db
 
 Copy [`.github/workflows-template/codeblast.yml`](.github/workflows-template/codeblast.yml) into your repo (it runs `npx codeblast pr-comment`, no other setup):
 every PR gets an automatic comment with structural changes + blast radius + new symbols with no test coverage; **PRs with no structural change get zero comments**.
-Replayed against 50 real commits: 42 correctly stayed silent, 87.5% of comments were useful.
+Replayed against 50 real commits: 42 correctly stayed silent. Comment usefulness is the honest weak spot —
+four review rounds — rounds 1–3 independent blind review, round 4 by the current model — scored 25% / 75% / 57% / 20% useful, against 7/8 = 87.5% when the
+authoring agent rated its own comments; both numbers and the fixes that followed each round are logged in
+[intent.md](intent.md).
 
 ## The precision promise (bounded, and evidence-backed)
 
 - **TypeScript at function level: zero missed impact within statically analyzable scope.** Verified by mutation testing:
   inject mutations into a real repo → run the full test suite to get the ground-truth impact set → compare against predictions.
-  Two benchmarks, both hard gates in the weekly acceptance workflow: **tRPC** (vitest, 950 files) **28/28**
+  Two benchmarks, both hard gates in the weekly acceptance workflow: **tRPC** (vitest, 957 files) **28/28**
   and **graphql-tools** (jest + npm workspaces, 353 files) **10/10** — 100% recall on each, average precision
   0.33–0.36. Favoring false positives over false negatives is a deliberate trade: in a controlled experiment,
-  dropping the conservative edges raises precision to 0.70 but recall collapses to 14%. Data lives in [`eval/`](eval/).
+  restricting the result to the call channel (items whose path is call-graph only) raises precision to 0.70 but recall collapses to 14%. Data lives in [`eval/`](eval/).
 - **Blind spots are explicitly flagged.** A blind spot is any call or import that static analysis cannot resolve to an in-repo target — dynamic calls, unresolved calls, failed external-dependency resolution, subprocess boundaries, test-framework globals — not just dynamic calls; each is recorded in `blind_spots` with an "impact may be underestimated" warning, never silently dropped.
 - **Python is file-level.** Dynamic typing makes function-level zero-miss guarantees impossible in principle, and we don't pretend otherwise.
 
+## When to use it
+
+- You are about to change an exported TypeScript symbol in a monorepo and want the callsite list and the test list *before* you edit, not after CI fails.
+- You are an AI agent editing code: `impact --json` before the edit puts the callsites in context, `change --json` after it catches scope creep and accidental deletions.
+- You are reviewing a PR and want the structural delta — edges added, symbols renamed, new symbols with no test coverage — separated from formatting noise.
+- You just inherited an unfamiliar TypeScript or Python repo and want a map whose every box and arrow can be opened at the source line that justifies it.
+- You need the answer to be checkable by someone who does not trust the tool.
+
+## When NOT to use it
+
+- **You want function-level guarantees on Python.** Python is file-level with typed-call upgrades; duck typing makes a zero-miss promise impossible in principle and we don't pretend otherwise.
+- **You want a short, precise impact list.** Mean precision is 0.33–0.36 overall; the call channel alone runs 0.702 (tRPC ablation) to 0.918 (graphql-tools) — a derived range, the min and max of the two per-benchmark means in [`eval/`](eval/), not one measured figure. The engine over-approximates on purpose — read the `call` channel first, treat the full list as the test set.
+- **Your dependencies run through what static analysis cannot resolve** — dynamic `require`, `eval`, subprocess boundaries, uninstalled `node_modules`, test-framework globals. Those are reported as `blind_spots`, never silently dropped, but such a repo gets a thin graph.
+- **You want a presentation diagram or a collaborative canvas.** `archmap` emits facts for navigation; feed its JSON to a rendering tool if you need something pretty.
+- **You want cross-service / cross-repo edges, or Java.** The graph model reserves the node types, v1 does not fill those edges, and Java is explicitly not implemented ([intent.md](intent.md)).
+- **You want the PR bot to replace a reviewer.** It is a structural-change signal whose usefulness measured between 20% and 75% depending on the review round.
+
+
+### Unified change safety check
+
+For agents and CI that need one decision instead of composing `change` and `impact`, run:
+
+```bash
+codeblast check-change <repo> <base-sha> <head-sha> --json
+```
+
+The output contains `decision` (`safe-to-review`, `targeted-review`, or `review`), `risk`, reasons,
+recommended actions, structural facts, predicted affected-test count, blind-spot count, truncation,
+and the complete graph diff. It is a conservative routing decision, not a claim that the change is
+safe to merge. `review` is required when API surface contracts, removed symbols, or incomplete impact
+results are detected.
 ## For AI agents
 
 ```
@@ -111,8 +182,28 @@ after editing:   change HEAD~1 HEAD --json → self-check for scope creep and ac
 The full contract and interpretation discipline (including "never pretend the blind-spot list is complete") is in [SKILL.md](SKILL.md).
 Agent conventions: [AGENTS.md](AGENTS.md).
 
+## FAQ
+
+**What exactly does the zero-miss promise cover?** Within the statically analyzable scope of an in-repo TypeScript codebase, the predicted set of affected test files is a superset of the tests that actually fail. That is verified by mutation testing on two independent repos — trpc/trpc 28/28 killed mutants, ardatan/graphql-tools 10/10 — and enforced by the weekly [`acceptance`](.github/workflows/acceptance.yml) workflow, which fails the run and opens an issue if recall drops below 100%. Anything static analysis cannot resolve is listed as a blind spot, and unqualified "zero-miss" wording is banned by project rule.
+
+**Why is precision so low, and is that a bug?** No, it is a measured trade. Mean precision is 0.358 on the 28-mutant tRPC run and 0.331 on the 10-mutant graphql-tools run, so most predicted affected tests do not fail. A controlled ablation that restricted the result to the call channel — a filter on the combined run (`predicted_call` in [`eval/mutation_check.py`](eval/mutation_check.py)) — raised call-channel precision to 0.702 and collapsed recall to 2 of 14 killed mutants. A later attempt to raise precision by pruning pure re-export barrels and narrowing interface fan-out was rejected by its own data because it would have produced guaranteed misses, so precision is no longer an optimization target.
+
+**Does it work on Python?** Yes, at file level, with typed-call upgrades that resolve named-import calls and constructor/annotation-derived method calls, which is enough for the architecture map and a file-level change map. The function-level zero-miss promise stays TypeScript-only. The Python example is the [sgp map](https://alloevil.github.io/codeblast/sgp-arch.html), including a detected `sgp_utils ⇄ solver_transfer` cycle.
+
+**How do I drive it from an AI coding agent?** Install it as a skill with `npx skills add alloevil/codeblast`, then run `codeblast impact <db> "<symbol>" --json` before editing and `codeblast change <repo> HEAD~1 HEAD --json` after. [SKILL.md](SKILL.md) carries the interpretation rules that matter: never present the impact list as complete while `blind_spot_count > 0`, never drop the `file` channel to shorten it, never claim function-level precision on Python, treat `truncated: true` as "run the full suite", and never report `co_change_hints` as impact.
+
+**Where are the numbers I can check?** Machine-readable claims with metric, method, repro command and evidence path are published at [claims.json](https://alloevil.github.io/codeblast/claims.json); the raw mutation and PR-replay runs are archived under [`eval/`](eval/) as records of runs that were made (the harness writes to `/tmp`, so the files are manual copies with no commit or version pin, and `mutation_check.py` picks candidates with `ORDER BY RANDOM()` — read them as archived runs, not as one-command regenerations), and the acceptance log with every downgrade and rejected optimization is [intent.md](intent.md).
+
+### PR bot feedback
+
+Feedback is intentionally issue-based and privacy-safe. Report only the public PR URL, the affected
+decision category, and a redacted explanation. Do not include source code, secrets, proprietary diffs,
+or full repository contents. The useful labels are false positive, missed impact, noise, incorrect
+silence, or incorrect recommendation. Feedback is qualitative calibration data; it is not telemetry
+and codeblast does not require access to customer repositories.
+
 ## Status & roadmap
 
-M0 graph engine → M1 Impact → M3 architecture map → M4 graph diff + PR bot → M5 precision extensions — **all milestones accepted** (each with a reproducible acceptance script). Single source of truth for design and acceptance criteria: [intent.md](intent.md).
+M0 graph engine → M1 Impact → M3 architecture map → M4 graph diff + PR bot → M5 precision extensions — **all shipped**; two acceptance steps were downgraded rather than passed (M2's verification method, and M3's original "10 minutes, 5 questions" test which was never run — ⚠️ in [intent.md](intent.md)), and the SemArc alignment check was dropped. Single source of truth for design and acceptance criteria: [intent.md](intent.md).
 
 MIT © 2026

package/README.zh-CN.md

@@ -1,3 +1,5 @@
+**codeblast** 是一个确定性代码图谱 CLI，面向 TypeScript / Python 仓库，让开发者和 AI agent 在合并之前就知道改动会炸到哪里。
+
 <p align="center">
   <img src="assets/readme/hero.svg" width="100%" alt="codeblast — deterministic code graph: know what breaks before you merge"/>
 </p>
@@ -13,6 +15,8 @@
   <img src="https://img.shields.io/badge/license-MIT-8b949e?style=flat-square" alt="MIT"/>
 </p>
 
+## 是什么
+
 **codeblast 把仓库解析成一份确定性代码图谱，回答改代码前后最贵的三个问题：**
 > 🔗 **[在线交互演示](https://alloevil.github.io/codeblast/)** — tRPC / Tabby / sgp 的实时架构图,点开即可三层下钻
 
@@ -24,6 +28,17 @@
 
 给人看（CLI / 交互 HTML / PR 评论），也给 AI agent 用（[SKILL.md](SKILL.md)）——同一份图谱，两个出口。
 
+## 安装
+
+```bash
+npx codeblast demo            # 给当前仓库建图、跑一次 impact 查询、导出架构图
+npm i -g codeblast            # 或全局安装；需要 Node ≥ 22.13（内置 sqlite）或 Bun
+                              # npm 上的版本是 0.3.1，与本仓库一致
+
+# 作为 agent skill 安装（Claude Code、Codex、Cursor 等）
+npx skills add alloevil/codeblast
+```
+
 ## 为什么不是又一个 LLM 画图工具
 
 ```
@@ -31,13 +46,13 @@ LLM 画图:    代码 → 模型阅读理解 → 手写图 → 渲染        图
 codeblast:   代码 → tsc/AST 确定性解析 → 图谱 → 投影    图 = 可验证的事实
 ```
 
-**每个节点、每条边、每句结论都带 `file:line` 证据**，可直接打开核对。
+**每个节点和每条静态分析边都带 `file:line` 证据**，可直接打开核对（`co_change` 边在该字段存的是共提交次数而非源码行；文件级节点行号为 1）。
 LLM 在管线里只做一件事：给模块起人话名字——节点归属和边永远来自静态分析。
 
 ## 三个查询
 
 ```bash
-# 建图：TS monorepo / Python 自动识别，hash 增量更新（tRPC 950 文件全量 ~20s）
+# 建图：TS monorepo / Python 自动识别，hash 增量更新（tRPC 957 文件：6248 节点 / 17072 边，样例运行见 SKILL.md）
 codeblast index <repo> --db graph.db
 
 # ① Impact —— 改动前查影响半径
@@ -60,18 +75,36 @@ codeblast cochange <repo> graph.db
 
 复制 [`.github/workflows-template/codeblast.yml`](.github/workflows-template/codeblast.yml) 到目标仓库：
 每个 PR 自动评论结构变化 + 影响半径 + 无测试覆盖的新增符号；**无结构变化的 PR 零评论**。
-50 个真实提交回放：42 个正确静默、评论有效率 87.5%。
+50 个真实提交回放：42 个正确静默。评论有效率是诚实的弱项——四轮评审（1–3 轮为独立盲评，第 4 轮由现模型担任评审人）为 25% / 75% / 57% / 20%，
+而作者 agent 自评同一批 8 条评论为 7/8 = 87.5%；两个数字与每轮之后的修复都记在 [intent.md](intent.md)。
 
 ## 精度承诺（有边界，有证据）
 
 - **TypeScript 函数级，静态可分析范围内零漏报。** 验收方法：变异测试对照
-  （真实仓库注入变异 → 全量测试得真实影响集 → 对比预测）。当前基准（tRPC，950 文件）：
+  （真实仓库注入变异 → 全量测试得真实影响集 → 对比预测）。当前基准（tRPC，957 文件）：
   **28/28 变异召回率 100%**，平均精确率 0.36——宁误报不漏报是刻意交换：
-  对照实验中砍掉保守边可将精确率提到 0.70，但召回率跌至 14%。数据在 [`eval/`](eval/)。
+  对照实验中把结果限制在调用链通道（对合并结果做 channel 过滤，见 `eval/mutation_check.py` 的 `predicted_call`）可将精确率提到 0.70，但召回率跌至 14%。数据在 [`eval/`](eval/)。
 - **盲区显式标注。** 盲区 = 静态无法解析到仓内目标的调用/导入（含动态调用、未解析调用、外部依赖解析失败、子进程边界、测试框架全局），并非只有动态调用；
   一律记入 blind_spots 并提示"影响可能被低估"，绝不静默丢弃。
 - **Python 为文件级。** 动态类型使函数级零漏报原理性不成立，不假装做到。
 
+## 什么时候用它
+
+- 你要改 monorepo 里某个导出符号，想在动手**之前**拿到 callsite 清单和必须跑的测试清单，而不是等 CI 红。
+- 你是在改代码的 AI agent：改前 `impact --json` 把 callsite 送进上下文，改后 `change --json` 自查越界与误删。
+- 你在评审 PR，想把结构变化（新增边、重命名符号、无测试覆盖的新符号）从格式噪音里分离出来。
+- 你刚接手一个陌生的 TS / Python 仓库，想要一张每个框每条边都能点开核对源码行的地图。
+- 你需要结论能被不信任本工具的人复核。
+
+## 什么时候不要用它
+
+- **你要 Python 的函数级保证。** Python 是文件级 + 类型化调用增强；鸭子类型使函数级零漏报原理性不成立，我们不假装做到。
+- **你要一份短而准的影响清单。** 全量平均精确率 0.33–0.36；单看 call 通道为 0.702（tRPC 对照实验）到 0.918（graphql-tools）——这是派生区间（两个基准均值的 min/max，数据在 [`eval/`](eval/)），不是单次实测。引擎刻意过近似：`call` 通道优先读，全量清单当作"要跑的测试"。
+- **你的依赖主要走静态分析看不见的路径** —— 动态 `require`、`eval`、子进程边界、未安装的 `node_modules`、测试框架全局。这些一律记入 `blind_spots` 不静默丢弃，但这样的仓库只会得到一张稀疏的图。
+- **你要的是演示用图或协作画布。** `archmap` 输出的是用于导航的事实；要好看的图请把它的 JSON 喂给渲染工具。
+- **你要跨服务 / 跨仓库边，或者 Java。** 图模型预留了节点类型但 v1 不填这些边，Java 明确未实现（见 [intent.md](intent.md)）。
+- **你想让 PR bot 代替评审人。** 它是结构变化信号，四轮评审（1–3 轮独立盲评，第 4 轮现模型自评）的有效率在 20%–75% 之间波动。
+
 ## 给 AI Agent 用
 
 ```
@@ -82,8 +115,20 @@ codeblast cochange <repo> graph.db
 完整契约与解读纪律（含"禁止假装盲区清单完整"）见 [SKILL.md](SKILL.md)。
 Agent 规范另见 [AGENTS.md](AGENTS.md)。
 
+## 常见问题
+
+**零漏报承诺的边界到底是什么？** 在"仓内静态可分析的 TypeScript"范围内，预测的受影响测试文件集是真实失败测试集的超集。验收方式是两个独立仓库上的变异测试——trpc/trpc 28/28 被杀死变异、ardatan/graphql-tools 10/10——并由每周的 [`acceptance`](.github/workflows/acceptance.yml) 工作流把守：召回率低于 100% 即失败并自动开 issue。任何静态无法解析的东西都记入盲区，且项目规则禁止使用无限定的"零漏报"表述。
+
+**精确率这么低是 bug 吗？** 不是，是被测量过的取舍。tRPC 30 变异集上平均精确率 0.358，graphql-tools 10 变异集上 0.331，即多数被预测的测试并不会失败。对照实验中把结果限制在 call 通道（对合并结果做过滤，见 `eval/mutation_check.py` 的 `predicted_call`）可把 call 通道精确率提到 0.702，但召回率跌到 14 个被杀死变异中的 2 个。后来一次"剪纯 re-export barrel + 收窄接口扇出"的精确率优化被自己的数据否决（必然产生漏报），因此精确率不再作为优化目标。
+
+**支持 Python 吗？** 支持，文件级，并带类型化调用增强（具名导入调用、构造赋值/注解推断出的方法调用），足以支撑架构图与文件级 Change Map。函数级零漏报承诺仍为 TypeScript 独有。Python 实例见 [sgp 架构图](https://alloevil.github.io/codeblast/sgp-arch.html)，其中检出了 `sgp_utils ⇄ solver_transfer` 循环依赖。
+
+**怎么让 AI agent 用它？** 用 `npx skills add alloevil/codeblast` 装成 skill，改前跑 `codeblast impact <db> "<symbol>" --json`，改后跑 `codeblast change <repo> HEAD~1 HEAD --json`。[SKILL.md](SKILL.md) 写明了关键解读纪律：`blind_spot_count > 0` 时禁止声称清单完整、禁止为了缩短清单砍掉 `file` 通道、禁止对 Python 声称函数级精度、`truncated: true` 要建议跑全量测试、`co_change_hints` 不等于影响。
+
+**可核对的数字在哪里？** 带指标、方法、复现命令和证据路径的机器可读清单发布在 [claims.json](https://alloevil.github.io/codeblast/claims.json)；原始变异与 PR 回放数据作为**运行存档**放在 [`eval/`](eval/)（harness 写的是 `/tmp`，这些文件是人工拷贝、不带 commit 或版本标注，候选用 `ORDER BY RANDOM()` 抽取——当存档读，别当作一条命令就能重跑出来的产物）；包含每次降级与被否决优化的验收台账是 [intent.md](intent.md)。
+
 ## 状态与路线
 
-M0 图谱引擎 → M1 Impact → M3 架构图 → M4 图 diff + PR bot → M5 精度扩展，**全部验收通过**（每项含可复现验收脚本）。方案与验收标准的单一事实源：[intent.md](intent.md)。
+M0 图谱引擎 → M1 Impact → M3 架构图 → M4 图 diff + PR bot → M5 精度扩展，**全部交付**；其中两项验收是降级而非通过（M2 的验证方式、M3 原定的"陌生工程师 10 分钟 5 问"从未执行——见 intent.md 的 ⚠️），SemArc 对齐检查已作废。方案与验收标准的单一事实源：[intent.md](intent.md)。
 
 MIT © 2026

package/SKILL.md

@@ -52,13 +52,17 @@ codeblast index <repo-root> --db /tmp/graph.db
 ```
 
 Auto-discovers every package `tsconfig.json` in a monorepo and ingests Python via AST. Re-running only
-processes files whose content hash changed. Stdout is one JSON object:
+processes files whose content hash changed. Stdout is one JSON object — this is a real run of
+`codeblast index` against [tRPC](https://github.com/trpc/trpc) at commit `66d0544` with the historical codeblast 0.3.0 benchmark
 
 ```json
-{ "db": "...", "seconds": 19.4, "tsconfigs": 12, "files_indexed": 950, "files_skipped": 0,
-  "nodes": 14200, "edges": 31800, "blind_spots": 412, "failures": 0 }
+{ "db": "/tmp/graph.db", "seconds": 5.2, "tsconfigs": 34, "files_indexed": 957, "files_skipped": 0,
+  "nodes": 6248, "edges": 17072, "blind_spots": 14725, "failures": 0 }
 ```
 
+Note that `blind_spots` is routinely large on a real TypeScript monorepo — it counts unresolved and
+dynamic references, not errors. Judge graph health by `failures`, not by `blind_spots`.
+
 Non-zero exit with `failures > 0` means the graph is incomplete — do not query it; report the failure.
 
 ## 2. Impact — what breaks if I change this
@@ -88,9 +92,21 @@ Output (`--json`):
     via_file: string; via_line: number;       // where the dependency occurs (rule 6)
   }>;
   co_change_hints: Array<{ file: string; co_commits: number; evidence: string }>;  // rule 5
+  guidance: {
+    review_first: string[];  // call-channel non-test nodes
+    run_tests: string[];     // test file paths, de-duplicate before running
+    conservative: string[];  // non-test file-channel nodes; never discard
+    warnings: string[];      // truncation and blind-spot warnings
+  };
 }
 ```
 
+The `guidance` object is a convenience projection of `items`; it does not add analysis results.
+Use `review_first` for the initial callsite checklist, `run_tests` for the affected test files,
+and `conservative` as the import/re-export safety net. `warnings` is non-empty when the result is
+incomplete or the target file contains unresolved analysis. Always retain `via_file` and `via_line`
+when reporting a dependency.
+
 How to use it: `items.filter(level === "direct")` is the callsite checklist. `items.filter(level ===
 "tests")` de-duplicated by `file` is the test set to run. Test-directory fixtures are included
 conservatively; estimate test cost by distinct files, not item count.
@@ -148,8 +164,9 @@ Replayed over 50 real commits: 42 stayed silent, 87.5% of the comments posted we
 
 - TypeScript, function level: **zero missed impact within statically analyzable scope**, checked by
   mutation testing (inject a fault, run the real test suite, compare failing tests to the prediction).
-  Two benchmarks: tRPC (vitest, 950 files) 28/28, graphql-tools (jest, 353 files) 10/10 — precision
-  0.33–0.36 overall, ≈ 0.70–0.92 on the call channel. Both are hard gates in the weekly acceptance
+  Two benchmarks: tRPC (vitest, 957 files) 28/28, graphql-tools (jest, 353 files) 10/10 — precision
+  0.33–0.36 overall; the call channel alone is 0.702–0.918 (derived: min/max of the two per-benchmark
+  means, see eval/). Both are hard gates in the weekly acceptance
   workflow, which opens an issue if either drops below 100%.
 - Conservative edges over-approximate on purpose (an interface method call fans out to every implementer).
 - Python: file-level; typed calls (`b = Builder(); b.method()`, annotated parameters) are function-level;

package/dist/bin.js

@@ -1131,7 +1131,16 @@ var init_impact_cli = __esm(() => {
   result = impact(db2, targetId, maxNodes);
   ms = (performance.now() - t02).toFixed(0);
   if (process.argv.includes("--json")) {
-    process.stdout.write(JSON.stringify(result) + `
+    const guidance = {
+      review_first: result.items.filter((it) => it.channel === "call" && it.level !== "tests").map((it) => it.id),
+      run_tests: result.items.filter((it) => it.level === "tests").map((it) => it.file),
+      conservative: result.items.filter((it) => it.channel === "file" && it.level !== "tests").map((it) => it.id),
+      warnings: [
+        ...result.truncated ? ["impact_truncated_run_full_test_suite"] : [],
+        ...result.blind_spot_count > 0 ? ["blind_spots_may_underestimate_impact"] : []
+      ]
+    };
+    process.stdout.write(JSON.stringify({ ...result, guidance }) + `
 `);
     db2.close();
     process.exitCode = 0;
@@ -1436,7 +1445,7 @@ async function layoutGraph(nodes, edges) {
     }))
   };
 }
-var CLIENT_JS, dbPath3, outFlag2, outPath2, overlayFlag, overlayPath, repoFlag, repoUrl, impactFlag, impactTarget, diffFlag, diffBase, db3, overlay, TEST_RE, moduleOf = (file) => {
+var CLIENT_JS, dbPath3, outFlag2, outPath2, overlayFlag, overlayPath, repoFlag, repoUrl, impactFlag, impactTarget, diffFlag, diffBase, siteFlag, siteUrl, ogImageFlag, ogImage, repoLabel, pageUrl, pageKind, pageTitle, pageDesc, escAttr = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;"), headMeta, db3, overlay, TEST_RE, moduleOf = (file) => {
   if (TEST_RE.test(file))
     return "tests";
   const ix = file.indexOf("/");
@@ -1460,6 +1469,51 @@ var init_archmap_html = __esm(async () => {
   impactTarget = impactFlag >= 0 ? process.argv[impactFlag + 1] : undefined;
   diffFlag = process.argv.indexOf("--diff");
   diffBase = diffFlag >= 0 ? process.argv[diffFlag + 1] : undefined;
+  siteFlag = process.argv.indexOf("--site-url");
+  siteUrl = siteFlag >= 0 ? process.argv[siteFlag + 1].replace(/\/+$/, "") : undefined;
+  ogImageFlag = process.argv.indexOf("--og-image");
+  ogImage = ogImageFlag >= 0 ? process.argv[ogImageFlag + 1] : undefined;
+  repoLabel = (() => {
+    const m = repoUrl?.match(/github\.com\/([^/]+\/[^/]+)/);
+    if (m)
+      return m[1].replace(/\.git$/, "");
+    const base = outPath2.split("/").pop() ?? outPath2;
+    return base.replace(/\.html$/, "");
+  })();
+  pageUrl = siteUrl ? `${siteUrl}/${outPath2.split("/").pop()}` : undefined;
+  pageKind = impactTarget ? "blast-radius map" : diffBase ? "change map" : "architecture map";
+  pageTitle = `${repoLabel} — ${pageKind}`;
+  pageDesc = `Interactive architecture map of ${repoLabel} generated by codeblast: a module-level` + ` dependency graph where hovering a node lights up its fan-in and clicking it shows its files,` + ` symbols and import edges.` + (impactTarget ? ` Includes the blast-radius overlay for ${impactTarget}.` : "") + (overlayPath ? " Includes the change overlay." : "");
+  headMeta = [
+    `<title>${escAttr(pageTitle)}</title>`,
+    `<meta name="description" content="${escAttr(pageDesc)}">`,
+    ...pageUrl ? [`<link rel="canonical" href="${escAttr(pageUrl)}">`] : [],
+    `<meta property="og:type" content="website">`,
+    `<meta property="og:title" content="${escAttr(pageTitle)}">`,
+    `<meta property="og:description" content="${escAttr(pageDesc)}">`,
+    ...pageUrl ? [`<meta property="og:url" content="${escAttr(pageUrl)}">`] : [],
+    `<meta property="og:site_name" content="codeblast">`,
+    ...ogImage ? [`<meta property="og:image" content="${escAttr(ogImage)}">`] : [],
+    `<meta name="twitter:card" content="${ogImage ? "summary_large_image" : "summary"}">`,
+    `<meta name="twitter:title" content="${escAttr(pageTitle)}">`,
+    `<meta name="twitter:description" content="${escAttr(pageDesc)}">`,
+    ...ogImage ? [`<meta name="twitter:image" content="${escAttr(ogImage)}">`] : [],
+    `<script type="application/ld+json">`,
+    JSON.stringify({
+      "@context": "https://schema.org",
+      "@type": "WebPage",
+      name: pageTitle,
+      description: pageDesc,
+      inLanguage: "zh-CN",
+      ...pageUrl ? { url: pageUrl } : {},
+      ...repoUrl ? {
+        isBasedOn: repoUrl,
+        about: { "@type": "SoftwareSourceCode", name: repoLabel, codeRepository: repoUrl }
+      } : {}
+    }, null, 2),
+    `</script>`
+  ].join(`
+`);
   if (!dbPath3) {
     console.error("usage: codeblast archmap <graph.db> --out arch.html");
     process.exit(1);
@@ -1629,10 +1683,10 @@ var init_archmap_html = __esm(async () => {
     fileEdges: importRows
   };
   html = `<!DOCTYPE html>
-<html lang="zh">
+<html lang="zh-CN">
 <head>
 <meta charset="utf-8">
-<title>codeblast · Architecture Map</title>
+${headMeta}
 <style>
   :root { --bg:#0d1117; --panel:#161b22; --border:#30363d; --fg:#e6edf3; --dim:#8b949e;
           --accent:#58a6ff; --warn:#f85149; --ok:#3fb950; }
@@ -1671,6 +1725,11 @@ var init_archmap_html = __esm(async () => {
   .edge.cyclic { stroke: var(--warn); stroke-dasharray: 5 3; stroke-width: 2;
     animation: cycflow 1.2s linear infinite; }
   @keyframes cycflow { to { stroke-dashoffset: -16; } }
+  /* 循环依赖用虚线静止表示即可 —— 虚线与颜色承载信息，流动只是让它更显眼。
+     reduced-motion 下停掉动画，而不是去掉虚线。 */
+  @media (prefers-reduced-motion: reduce) {
+    .edge.cyclic { animation: none; }
+  }
   .edge.hi { stroke: #d29922 !important; stroke-width: 2.6; stroke-opacity: 1; }
   .edge.dim { stroke-opacity: 0.1; }
   .edge.faint { stroke-opacity: 0.06; }
@@ -1955,6 +2014,54 @@ var init_pr_silence = __esm(() => {
   AUX_RE = /^(www|docs|examples)\//;
 });
 
+// src/pr-decision.ts
+function reviewDecision(input) {
+  const { diff, prodNodesAdded, bodyChanged, affectedTests, truncated, blindSpotCount } = input;
+  const apiContractions = diff.visibilityChanged.filter((v) => !v.nowExported).length;
+  const apiChanges = apiContractions + diff.signatureChanged.length;
+  const removals = diff.nodesRemoved.length;
+  const behaviorChanges = bodyChanged.length;
+  const reasons = [];
+  const recommendedActions = [];
+  let risk = "low";
+  if (apiContractions > 0 || removals > 0 || truncated)
+    risk = "high";
+  else if (apiChanges > 0 || behaviorChanges > 0 || affectedTests > 0 || blindSpotCount > 0)
+    risk = "medium";
+  if (apiContractions > 0)
+    reasons.push(`${apiContractions} exported symbol${apiContractions === 1 ? " is" : "s are"} no longer public`);
+  if (removals > 0)
+    reasons.push(`${removals} symbol${removals === 1 ? " was" : "s were"} removed`);
+  if (diff.signatureChanged.length > 0)
+    reasons.push(`${diff.signatureChanged.length} exported signature${diff.signatureChanged.length === 1 ? " changed" : "s changed"}`);
+  if (behaviorChanges > 0)
+    reasons.push(`${behaviorChanges} function bod${behaviorChanges === 1 ? "y" : "ies"} changed`);
+  if (affectedTests > 0)
+    reasons.push(`${affectedTests} test file${affectedTests === 1 ? " is" : "s are"} in the predicted impact set`);
+  if (truncated)
+    reasons.push("the impact set exceeded the reporting limit");
+  if (blindSpotCount > 0)
+    reasons.push(`${blindSpotCount} static-analysis blind spot${blindSpotCount === 1 ? "" : "s"} may hide impact`);
+  if (reasons.length === 0 && prodNodesAdded.length > 0)
+    reasons.push(`${prodNodesAdded.length} production symbol${prodNodesAdded.length === 1 ? " was" : "s were"} added`);
+  if (reasons.length === 0)
+    reasons.push("only low-risk structural additions were found");
+  if (apiChanges > 0 || removals > 0)
+    recommendedActions.push("Review the public API changes and migration impact.");
+  if (truncated)
+    recommendedActions.push("Run the full test suite; the reported impact list is truncated.");
+  else if (affectedTests > 0)
+    recommendedActions.push(`Run the ${affectedTests} predicted affected test file${affectedTests === 1 ? "" : "s"}.`);
+  if (blindSpotCount > 0)
+    recommendedActions.push("Inspect the reported blind spots before treating the impact set as complete.");
+  if (behaviorChanges > 0)
+    recommendedActions.push("Review the changed function bodies even where the exported shape is unchanged.");
+  if (recommendedActions.length === 0)
+    recommendedActions.push("Review the named structural additions; no existing API contraction was detected.");
+  const summary = risk === "high" ? "Review before merge: the change removes API surface, deletes symbols, or has an incomplete impact set." : risk === "medium" ? "Targeted review recommended: behavior, API shape, tests, or blind spots changed." : "Low structural risk: only additive changes with no predicted affected tests were found.";
+  return { risk, summary, reasons, recommendedActions };
+}
+
 // src/pr-comment.ts
 var exports_pr_comment = {};
 import fs7 from "node:fs";
@@ -1993,7 +2100,7 @@ var args3, repo2, baseSha, headSha, urlFlag, repoUrl2, dbPathA = "/tmp/codeblast
   const wrap = s.kind === "interface" || s.kind === "const" ? (t) => t : (t) => `(${t})`;
   const what = s.kind === "interface" ? "成员变化" : s.kind === "const" ? "类型变化" : "";
   return `- \`${s.name}\`${what ? ` ${what}` : ""}: \`${wrap(clip(s.from))}\` → \`${wrap(clip(s.to))}\` （${link(s.file, s.line)}）`;
-}, apiSig, testSig, uncovered, impactRows, prodNodesAdded, diffLineCount, bodySignal, coreNamed;
+}, apiSig, testSig, uncovered, impactRows, affectedTestCount = 0, anyImpactTruncated = false, totalBlindSpots = 0, prodNodesAdded, diffLineCount, bodySignal, coreNamed, decision;
 var init_pr_comment = __esm(async () => {
   init_db();
   init_proc();
@@ -2106,6 +2213,9 @@ var init_pr_comment = __esm(async () => {
       const r = impact(dbB2, n.id, 2000);
       const callItems = r.items.filter((i) => i.channel === "call");
       const tests = callItems.filter((i) => i.level === "tests").length;
+      affectedTestCount += tests;
+      anyImpactTruncated ||= r.truncated;
+      totalBlindSpots += r.blind_spot_count;
       impactRows.push(`| \`${n.name}\` | ${n.kind} | ${callItems.length} | ${tests} | ${link(n.file, n.line)} |`);
       const blind = r.blind_spot_count > 0;
       if (tests === 0 && n.kind !== "interface" && n.kind !== "const") {
@@ -2153,16 +2263,101 @@ var init_pr_comment = __esm(async () => {
   if (total2 === 0 && bodyChanged.length > 0) {
     lines3[2] = `**无结构变更**,但有 ${bodyChanged.length} 个函数体内改动（见下）`;
   }
+  decision = reviewDecision({
+    diff: diff2,
+    prodNodesAdded,
+    bodyChanged,
+    affectedTests: affectedTestCount,
+    truncated: anyImpactTruncated,
+    blindSpotCount: totalBlindSpots
+  });
+  lines3.splice(3, 0, `> **Review decision · ${decision.risk.toUpperCase()}** — ${decision.summary}`, `> ${decision.reasons.join("; ")}.`, ``, `### Recommended checks`, ``, ...decision.recommendedActions.map((action) => `- ${action}`), ``);
   lines3.push(`<sub>由 [codeblast](https://github.com/alloevil/codeblast) 生成 · 每条结论基于静态分析,含证据链接 · 动态调用盲区不在本报告内 · 评论不准?[30 秒反馈](https://github.com/alloevil/codeblast/issues/new?template=bot-feedback.yml&title=${encodeURIComponent(`[feedback] ${baseSha.slice(0, 7)}..${headSha.slice(0, 7)}`)})</sub>`);
   console.log(lines3.join(`
 `));
 });
 
+// src/check-change.ts
+var exports_check_change = {};
+import fs8 from "node:fs";
+function buildGraphAt3(ref, db) {
+  const wt = `/tmp/codeblast-check-${ref.replace(/[^\w]/g, "_")}`;
+  spawnSync(["git", "worktree", "remove", "--force", wt], { cwd: repo3 });
+  const add = spawnSync(["git", "worktree", "add", "--detach", wt, ref], { cwd: repo3 });
+  if (add.exitCode !== 0)
+    throw new Error(add.stderr.slice(0, 300));
+  try {
+    const built = spawnSync(selfCommand("index", wt, "--db", db));
+    if (built.exitCode !== 0)
+      throw new Error(built.stderr.slice(0, 500));
+  } finally {
+    spawnSync(["git", "worktree", "remove", "--force", wt], { cwd: repo3 });
+  }
+}
+var repo3, baseSha2, headSha2, dbAPath = "/tmp/codeblast-check-base.db", dbBPath = "/tmp/codeblast-check-head.db", dbA3, dbB3, diff3, prodNodesAdded2, bodyChanged2, total3, affectedTests = 0, truncated = false, blindSpots = 0, diffLineCount2, decision2, output;
+var init_check_change = __esm(() => {
+  init_db();
+  init_proc();
+  init_impact();
+  init_pr_silence();
+  [repo3, baseSha2, headSha2] = process.argv.slice(2);
+  if (!repo3 || !baseSha2 || !headSha2) {
+    console.error("usage: codeblast check-change <repo> <base-sha> <head-sha> --json");
+    process.exit(1);
+  }
+  for (const f of [dbAPath, dbBPath])
+    for (const suffix of ["", "-wal", "-shm"])
+      fs8.rmSync(f + suffix, { force: true });
+  buildGraphAt3(baseSha2, dbAPath);
+  buildGraphAt3(headSha2, dbBPath);
+  dbA3 = openDatabase(dbAPath, { readonly: true });
+  dbB3 = openDatabase(dbBPath, { readonly: true });
+  diff3 = graphDiff(dbA3, dbB3);
+  prodNodesAdded2 = diff3.nodesAdded.filter((n) => !TEST_RE3.test(n.file));
+  bodyChanged2 = [];
+  total3 = structuralTotal(diff3);
+  for (const node of [...diff3.nodesAdded, ...diff3.renamed.map((r) => ({ id: `${r.file}#${r.to}`, kind: r.kind, name: r.to, file: r.file, line: 0 }))].slice(0, 15)) {
+    try {
+      const result = impact(dbB3, node.id, 2000);
+      affectedTests += new Set(result.items.filter((item) => item.level === "tests").map((item) => item.file)).size;
+      truncated ||= result.truncated;
+      blindSpots += result.blind_spot_count;
+    } catch {}
+  }
+  diffLineCount2 = spawnSync(["git", "diff", "--numstat", baseSha2, headSha2], { cwd: repo3 }).stdout.split(`
+`).reduce((sum, line) => {
+    const match = line.match(/^(\d+)\t(\d+)\t/);
+    return sum + (match ? Number(match[1]) + Number(match[2]) : 0);
+  }, 0);
+  decision2 = reviewDecision({ diff: diff3, prodNodesAdded: prodNodesAdded2, bodyChanged: bodyChanged2, affectedTests, truncated, blindSpotCount: blindSpots });
+  output = {
+    range: `${baseSha2}..${headSha2}`,
+    decision: decision2.risk === "high" ? "review" : decision2.risk === "medium" ? "targeted-review" : "safe-to-review",
+    risk: decision2.risk,
+    summary: decision2.summary,
+    reasons: decision2.reasons,
+    recommended_actions: decision2.recommendedActions,
+    structural_changes: total3,
+    affected_test_files: affectedTests,
+    blind_spot_count: blindSpots,
+    truncated,
+    signals: {
+      core_named: coreNamedCount(diff3, prodNodesAdded2),
+      body: bodySignalCount(bodyChanged2, diffLineCount2, () => false),
+      aux_only: total3 > 0 && coreNamedCount(diff3, prodNodesAdded2) === 0 && bodyChanged2.length === 0
+    },
+    diff: diff3
+  };
+  console.log(JSON.stringify(output));
+  dbA3.close();
+  dbB3.close();
+});
+
 // src/demo.ts
 var exports_demo = {};
-import fs8 from "node:fs";
+import fs9 from "node:fs";
 import path3 from "node:path";
-var repo3, db6 = "/tmp/codeblast-demo.db", out = "/tmp/codeblast-demo-arch.html", run = (label, args) => {
+var repo4, db6 = "/tmp/codeblast-demo.db", out = "/tmp/codeblast-demo-arch.html", run = (label, args) => {
   console.log(`
 \x1B[36m▸ ${label}\x1B[0m`);
   console.log(`  $ codeblast ${args.slice(2).join(" ")}`);
@@ -2182,12 +2377,12 @@ var repo3, db6 = "/tmp/codeblast-demo.db", out = "/tmp/codeblast-demo-arch.html"
 var init_demo = __esm(() => {
   init_db();
   init_proc();
-  repo3 = path3.resolve(process.argv[2] ?? path3.join(import.meta.dirname, ".."));
-  console.log(`codeblast demo — target: ${repo3}`);
+  repo4 = path3.resolve(process.argv[2] ?? path3.join(import.meta.dirname, ".."));
+  console.log(`codeblast demo — target: ${repo4}`);
   for (const s of ["", "-wal", "-shm"])
-    fs8.rmSync(db6 + s, { force: true });
-  run("1/4 build graph", selfCommand("index", repo3, "--db", db6));
-  run("2/4 incremental rerun (should skip everything)", selfCommand("index", repo3, "--db", db6));
+    fs9.rmSync(db6 + s, { force: true });
+  run("1/4 build graph", selfCommand("index", repo4, "--db", db6));
+  run("2/4 incremental rerun (should skip everything)", selfCommand("index", repo4, "--db", db6));
   conn = openDatabase(db6, { readonly: true });
   pick = conn.prepare(`SELECT n.id, COUNT(DISTINCT e.src) c FROM nodes n
    JOIN edges e ON e.dst = n.id AND e.kind = 'calls'
@@ -2212,7 +2407,7 @@ var init_demo = __esm(() => {
 
 // src/name-modules.ts
 var exports_name_modules = {};
-import fs9 from "node:fs";
+import fs10 from "node:fs";
 var dbPath6, overlayFlag2, overlayPath2, db7, TEST_RE4, files3, byModule, symStmt, evidence, prompt, cmd;
 var init_name_modules = __esm(async () => {
   init_db();
@@ -2250,7 +2445,7 @@ ${JSON.stringify(evidence, null, 1)}`;
   if (!cmd) {
     const applyFlag = process.argv.indexOf("--apply");
     if (applyFlag >= 0) {
-      const namesJson = JSON.parse(fs9.readFileSync(process.argv[applyFlag + 1], "utf8"));
+      const namesJson = JSON.parse(fs10.readFileSync(process.argv[applyFlag + 1], "utf8"));
       const overlay = await loadOverlay(overlayPath2);
       for (const [mod, v] of Object.entries(namesJson)) {
         const existing = overlay.modules[mod];
@@ -2259,7 +2454,7 @@ ${JSON.stringify(evidence, null, 1)}`;
         overlay.modules[mod] = { ...existing, name: `${v.name}`, ...v.desc ? {} : {} };
         overlay.modules[mod].desc = v.desc;
       }
-      fs9.writeFileSync(overlayPath2, JSON.stringify(overlay, null, 2));
+      fs10.writeFileSync(overlayPath2, JSON.stringify(overlay, null, 2));
       console.error(`overlay written: ${overlayPath2}`);
     } else {
       console.log(prompt);
@@ -2276,7 +2471,7 @@ ${JSON.stringify(evidence, null, 1)}`;
       overlay.modules[mod] = { ...overlay.modules[mod], name: v.name };
       overlay.modules[mod].desc = v.desc;
     }
-    fs9.writeFileSync(overlayPath2, JSON.stringify(overlay, null, 2));
+    fs10.writeFileSync(overlayPath2, JSON.stringify(overlay, null, 2));
     console.error(`overlay written: ${overlayPath2}`);
   }
 });
@@ -2290,6 +2485,7 @@ var ROUTES = {
   mermaid: () => Promise.resolve().then(() => (init_archmap(), exports_archmap)),
   cochange: () => Promise.resolve().then(() => (init_cochange(), exports_cochange)),
   "pr-comment": () => init_pr_comment().then(() => exports_pr_comment),
+  "check-change": () => Promise.resolve().then(() => (init_check_change(), exports_check_change)),
   demo: () => Promise.resolve().then(() => (init_demo(), exports_demo)),
   "name-modules": () => init_name_modules().then(() => exports_name_modules)
 };
@@ -2304,9 +2500,12 @@ usage: codeblast <command> [args]
   change    <repo> <ref-a> <ref-b> [--json]     structural diff between two refs
   archmap   <graph.db> --out arch.html          interactive architecture map
             [--impact <sym>] [--diff <base.db>]   ...with impact / change overlay
+            [--repo-url <url>]                    names the page and its JSON-LD (already used above)
+            [--site-url <base>] [--og-image <u>]  canonical/og for the published page (optional)
   mermaid   <graph.db>                          module map as mermaid
   cochange  <repo> <graph.db>                   mine git history coupling
   pr-comment <repo> <base-sha> <head-sha>       PR review comment (silent if no change)
+  check-change <repo> <base-sha> <head-sha>     machine-readable merge safety decision
   demo      [repo]                              build + query + map in one shot
 
 docs: https://github.com/alloevil/codeblast · demos: https://alloevil.github.io/codeblast/`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeblast",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Know what breaks before you merge — mutation-tested code graph with architecture, change & impact maps. Evidence on every edge. For humans and AI agents.",
   "keywords": [
     "impact-analysis",