@mmerterden/multi-agent-pipeline 16.11.0 → 16.13.0

package/CHANGELOG.md

@@ -16,6 +16,55 @@ Internal file-layout changes that don't affect the slash-command surface are sti
 
 ## [Unreleased]
 
+## [16.13.0] - 2026-08-28
+
+### Added
+
+- **`/multi-agent:graph`  -  a deterministic code graph, built without an LLM.** Phase 1 re-scanned the repo with grep and read on every task and defaulted to the "very thorough" tier on feature work; Phase 7 wrote `architecture.md` from one task's window and let it age for 90 days. Both wanted the same answer: where does this live, and what depends on it. `graph-build.mjs` extracts symbols, imports and references by regex over comment-stripped source into `~/.claude/knowledge/<project>/code-graph.json`; `graph-query.mjs` runs a token-budgeted traversal, `graph-affected.mjs` walks it backwards for impact, `graph-report.mjs` renders `GRAPH_REPORT.md`, and `validate-code-graph.mjs` fails a build whose edges point at missing nodes. Zero runtime dependencies, zero API cost, read-only on the repo. Design reference: `Graphify-Labs/graphify`; the reasoning, the trade and the numbers are in `docs/adr/0010-own-code-graph.md`.
+- **Phase 1 Step 2.6 and Phase 7 graph refresh, behind `prefs.global.codeGraph.enabled` (default `false`).** When on, Phase 1 queries the graph and hands Explore a ranked starting set instead of a full scan, and Phase 7 rebuilds the graph after the branch changed code. Off, the pipeline behaves exactly as before. Measured on a 4,300-file Swift app at a fixed 30k retrieval budget: 80.4% coverage at 18,465 tokens against 66.0% at 24,555 for grep-and-read. The win is entirely in domain-word searches (63.3% vs 32.0% at under half the cost); when the task already names an exact type, `grep -lw` is still slightly better and slightly cheaper, and the command says so.
+- **`_path-match.mjs`.** The glob matcher `test-gap-scan.mjs` carried inline is now shared with the graph engine, so the two cannot drift apart on what a repo excludes.
+- **Code-graph rules for Android, Node and Python.** Four stacks now build: measured on a 4,229-file Kotlin app (25,234 nodes, 70,897 edges), this repo (126 sources) and a 43-file Python service, each validated and each hub list checked by hand rather than assumed correct. Two engine defects surfaced doing it, both of which iOS had been getting away with. Nesting was read from the pattern's match column, so `public final class Foo` counted as nested because the match starts at `class` seven columns in; it now reads the line's indentation. And the import pass read a fully stripped body, which blanks a JavaScript module specifier because the specifier IS a string literal - every import edge in that stack would have vanished with nothing to notice it. iOS was re-gated after both and scored identically (80.4% at 18,467 tokens).
+- **A nested declaration is a node but never a reference target.** Kotlin sealed cases and Python inner classes are named after the concept they model - `Icon`, `Color`, `Success`, `Disabled` - and each is declared exactly once, so the ambiguity rule never caught them. Every Kotlin file that merely mentioned Compose's `Color` gained an edge to one app's nested case: 4,072 false edges out of 74,969, and four of the top eight architectural hubs were wrong. They stay findable by name through their `defines` edge.
+- **`prefs.global.modelFallback.fableEnabled` (default `true`)  -  the fable rung as a switch, not only as a fallback.** Every other trigger in the fallback contract reacts to something going wrong; this one asserts up front that a rung is not in play, so there is no dispatch attempt and no error to recover from. `false` starts `ios/android/backend-architect`, `code-reviewer` and triage on `opus`. Claude Code only: Copilot CLI does not offer Fable 5, and on Codex CLI the `fable` rung means `gpt-5.6 @ xhigh`, a different vendor's model on a different account, which the switch deliberately leaves alone. Turning it off also collapses the Phase 4 Claude Code panel to two reviewers, because Reviewer 1 lands on the `opus` Reviewer 2 already holds and one model dispatched twice is not cross-model review; `consensus.reviewerCount` records `2`. Set `costBudget.priceAt` to `opus` alongside it, or the estimate keeps pricing at a rung nothing runs on and trips the ceiling early.
+
+### Fixed
+
+- **`derivedSkillSources` could not say which repo held the derived copies.** `localPath` reads as relative to the current repo, so both entries pointed at the UPSTREAM tree and stayed wrong through a plugin rename: the drift check was comparing a path that did not exist. Added `localRepo`, corrected both entries, and re-derived their skill lists from the tree instead of from memory.
+- **Two `excludePathGlobs` shapes were silently inert.** A pattern with a wildcard and no `**` fell through to a literal `endsWith` / `includes` test against the pattern text, which can never be true: nothing ends with the characters `*.d.ts`. So `*.d.ts` in the node rules and `*.egg-info/` in the python rules excluded nothing, and generated typings and build residue reached every consumer of those rules, `test-gap-scan.mjs` included. Both shapes now translate to an anchored regex, and eight glob cases are pinned by the smoke.
+- **`--all-data` left the knowledge base behind.** Full uninstall removed the log root and the per-repo memory root but never `~/.claude/knowledge/`, which holds `architecture.md`, `patterns.md`, `gotchas.md`, `decisions.md` and now `code-graph.json`. That is prose about a private codebase plus every symbol name in it, and it is the data a user most likely means by "remove everything". A default uninstall still keeps all of it, and memory written inside a repo (`$PROJECT_ROOT/.multi-agent/memory/`) is still never touched by either mode: it lives in the user's working tree and may be committed.
+- **`modelFallback.floorModel` could not be set.** The fallback contract has documented it since the two-step ladder landed, but it was absent from `prefs.schema.json`, whose `modelFallback` object forbids extra keys  -  so a prefs file that followed the documented example failed validation. Declared, defaulted to `haiku`, and added to the template.
+- **The consensus rule still claimed two reviewers on Claude Code.** v16.12.0 added the third reviewer and updated the matrix but not the `reviewerCount` line 300 lines below it. `smoke-cross-cli-behavior.sh` reads the matrix, so it never noticed. The line now says what it should have said all along: the count is the reviewers that actually dispatched, not the configured maximum.
+
+
+## [16.12.0] - 2026-08-27
+
+### Added
+
+- **`/multi-agent:analysis` reviews the document before publishing it.** It had no review phase: the only pre-dispatch gate was a structural validator, so nothing ever read what was about to reach Confluence, and one real run published a channel it never searched for, an open question about a frame it never opened, and twenty-three unowned `EKLENECEK` markers. Phase 3.2 runs `phase-4-review.md` Step 0 (the analysis branch that already existed and nothing called) on the draft, before the destination is chosen. Reviewers are subagents holding `analysis/review.md`, never the context that wrote the document, because a context cannot notice a search it never thought to run. A blocking finding returns to synthesis with dispatch closed and never becomes an open question. Locked 36.
+- **Phase 3.3 closes gaps instead of writing them down.** Reachable evidence is searched and never asked about, decisions the user owns are asked, and only external gaps enter the document as `AS-NN` rows with an owner. A gap with neither a `searched, not found` nor an `asked, external` stamp fails the dispatch gate. Autopilot runs both phases; only the asking degrades.
+- **A third reviewer on Claude Code.** Opus fills the slot GPT-5.4 occupies on Copilot and Codex, so every host now runs three: Fable + Opus + Sonnet here. A finding two independent readers both miss is one triage has no chance to catch.
+- **`figma-screenshot.sh --discover-sections`.** One `GET ?depth=3` lists every section whose name matches the feature, with a frame count and a channel guess, folding diacritics so `Elite` and `Elit` are the same word. A channel may no longer be called missing until this returns nothing, and the record must cite the scan (Locked 12). Verified against the file that caused the defect: it returns both the Desktop section and the mobileWeb sibling the run had declared absent.
+- **Four validator gates**: `AS-NN` matched in both directions, `EKLENECEK` without an id, JSON inside a service-table cell, and Turkish diagram labels flattened to ASCII inside a mermaid fence, which the punctuation gate skips.
+
+### Changed
+
+- **"All variants drilled" now means read, not counted** (Locked 19). Visible `TEXT` layers inside each frame's own bounds are extracted, hidden layers and overflowing component boilerplate dropped. A frame can be called out of scope only by quoting its own text, and opening an open question about a frame nobody read fails the gate. One run logged a frame named `08 Payment` as ambiguous while its text spelled out the whole payment step.
+- **Every frame-inventory row gets an embedded image** (Locked 18). The gallery is generated from the inventory rather than hand-picked; narrowing to a canonical subset for page weight is not a call the run makes alone. One run uploaded 34 attachments and embedded 14, and was reported as "frames not uploaded" - the files were there and invisible.
+- **Embedded images carry a display width.** `md2confluence-v3.py --image-width` defaults to 720 with a per-image `![](f.png "width=320")` override; the attachment stays full resolution. A 2x phone export is 750x1624 and took two screen heights at natural size.
+- **Service tables put payloads under the table, not in a cell.** `Request` and `Response` carry one of three states; JSON goes in a fenced block below, field notes in their own table. A whole-unknown contract is one line, not six `EKLENECEK` cells.
+
+### Fixed
+
+- **`md2confluence` re-upload logged one warning per attachment and lost nothing.** The already-exists path was keyed off HTTP 400, and this Confluence Server answers 500 for a duplicate filename, so the update path was unreachable. It looks before creating now; 400, 409 and 500 remain handled as the race they should always have been. `attachments_updated` is counted apart from `attachments_uploaded`, because "0 uploaded, 12 warnings" reads as data loss when nothing was lost.
+- **The mermaid fallback lost every edge in any diagram whose nodes carry labels.** The pattern required the node id to sit next to the arrow, so `A[Basla] --> B` matched nothing - not just labelled branches, the whole flow. Both label syntaxes are captured now and the label is kept (`Evet -> Odeme Yap`), and the source ships beside the list so the diagram is recoverable.
+
+### Internal
+
+- **This release sets the `required` dist-tag.** An install older than 16.12.0 does not produce a worse analysis document, it produces one that has to be redone: no review before publishing, gaps recorded instead of closed, a channel called missing without the file ever being scanned, and frame filenames where the pictures belong. That is the criterion in the Supported Version Gate, so the tag is set rather than left off.
+- The analysis ref ceiling moves 148000 -> 154000 across two raises in one session. Everything that could live outside the count already does: the scan in `figma-screenshot.sh`, the reviewer rubric in `analysis/review.md` which a subagent loads and the orchestrator does not, and all four new gates in `validate-analysis-doc.mjs`. The tree was measured for reclaimable duplication first and had none.
+- `smoke-validate-analysis-doc.sh` replaces four section-number pairing assertions with the `AS-NN` contract in both directions.
+
+
 ## [16.11.0] - 2026-08-27
 
 ### Changed

package/README.md

@@ -62,11 +62,13 @@ One command runs 8 phases, with a gate between the risky ones:
 - **1 · Analysis** - detect the stack, scan the codebase, map impact (Sonnet).
 - **2 · Plan** - write a task breakdown and **stop for your approval** before touching code.
 - **3 · Dev** - TDD: failing test → code → green, following the repo's style + the active stack skills.
-- **4 · Review** - deterministic gates (build / lint / test / secret-scan) must pass first, then a **CLI-aware parallel review** - Claude Code runs 2 models (Fable + Sonnet), Copilot CLI runs 3 (GPT-5.4 + Opus + Sonnet) - and a **Fable triage** keeps only actionable findings; blockers loop back to Phase 3.
+- **4 · Review** - deterministic gates (build / lint / test / secret-scan) must pass first, then a **CLI-aware parallel review** - Claude Code runs 3 models (Fable + Opus + Sonnet), Copilot CLI runs 3 (GPT-5.4 + Opus + Sonnet) - and a **Fable triage** keeps only actionable findings; blockers loop back to Phase 3.
 - **5 · Test** - build + run the suite; success is required (no faked passes).
 - **6 · Commit/PR** - conventional commit, push (must succeed), open a PR (`Ref: #N`, never auto-close).
 - **7 · Report** - technical summary + a Jira comment with test scenarios, posted through the channels layer.
 
+`/multi-agent:analysis` runs its own shorter chain and, since v16.12.0, reviews what it wrote before publishing it: the draft goes through the same three-reviewer set and triage as a code diff, a blocking finding returns it to synthesis with dispatch closed, and the gaps that survive are either searched, asked about, or recorded with an owner. It used to publish behind a structural validator alone.
+
 Under the hood: each task runs in its own **git worktree** (or the current branch with `:local`), commits use the **git identity routed from the repo's origin URL**, and **multi-repo** tasks get per-repo worktrees plus an integration build. Tokens stay in the OS keychain; nothing is committed or logged. `/multi-agent:review` can also review an existing GitHub/Bitbucket PR - per-finding inline comments anchored to `file:line` + an explicit Approve / Needs-Work state.
 
 The discipline behind all of this - bounded loops, evidence gates, token-budgeted phase docs, immutable tests, fresh-context handoffs - is catalogued in [docs/engineering.md](./docs/engineering.md). The full feature list lives in [docs/features.md](./docs/features.md). How this repo, the `multi-agent-plugins` marketplace, and the `multi-agent-toolkit-mcp` server compose at install time and at run time is diagrammed in [docs/ecosystem.md](./docs/ecosystem.md).
@@ -87,7 +89,7 @@ Depth, autopilot and `--local` are the only knobs on the run itself; everything
 
 ## Commands
 
-`/multi-agent` plus 53 sub-commands. `/multi-agent:help` renders the same catalog in your terminal, in your `outputLanguage`.
+`/multi-agent` plus 54 sub-commands. `/multi-agent:help` renders the same catalog in your terminal, in your `outputLanguage`.
 
 ### Pipeline entries
 
@@ -206,13 +208,13 @@ This enables the matching plugin (+ the shared `ai-common` plugin) in the repo's
 
 ## Tool support
 
-The pipeline runs natively on **Claude Code**, **Copilot CLI** and **Codex CLI** - all three install from the same `pipeline/` source and get the same 53 commands.
+The pipeline runs natively on **Claude Code**, **Copilot CLI** and **Codex CLI** - all three install from the same `pipeline/` source and get the same 54 commands.
 
 | Tool | Flag | What it installs |
 |---|---|---|
 | Claude Code | `--claude` (default) | slash commands + skills + agents + `PreToolUse` secret-scan hook |
-| Copilot CLI | `--copilot` | instructions + 53 sub-command skills + scripts |
-| Codex CLI | `--codex` | one router skill + 53 specs as refs + 8 agent TOML + `AGENTS.md` block + `codex mcp add` |
+| Copilot CLI | `--copilot` | instructions + 54 sub-command skills + scripts |
+| Codex CLI | `--codex` | one router skill + 54 specs as refs + 8 agent TOML + `AGENTS.md` block + `codex mcp add` |
 
 Filter skills by stack with `--platform=ios\|android\|all`.
 
@@ -223,8 +225,8 @@ error. Measured on 0.145: installing one plugin that declares 142 skills surface
 `multi-agent` router and keeps the sub-command specs as reference files that cost
 nothing until read - same commands, same behaviour, a layout the host can actually hold.
 
-Reviewer sets differ because the available models do: Claude Code runs 2 reviewers
-(Fable + Sonnet), Copilot CLI 3 (Opus + GPT-5.4 + Sonnet), Codex CLI 3 (gpt-5.6 at
+Reviewer sets differ because the available models do: Claude Code runs 3 reviewers
+(Fable + Opus + Sonnet), Copilot CLI 3 (Opus + GPT-5.4 + Sonnet), Codex CLI 3 (gpt-5.6 at
 xhigh, gpt-5.4, gpt-5.6 at medium). Codex is single-vendor, so consensus among its three
 is weaker evidence than the same consensus on a two-vendor host, and the triage note
 says so.

package/README.tr.md

@@ -62,11 +62,13 @@ Tek komut 8 fazı çalıştırır, riskli olanlar arasında bir kapı ile:
 - **1 · Analysis** - stack'i tespit et, codebase'i tara, etkiyi haritala (Sonnet).
 - **2 · Plan** - bir görev kırılımı yaz ve koda dokunmadan önce **onayın için dur**.
 - **3 · Dev** - TDD: başarısız test → kod → yeşil, repo'nun stiline + aktif stack skill'lerine uyarak.
-- **4 · Review** - önce deterministik kapılar (build / lint / test / secret-scan) geçmeli, sonra bir **CLI-farkında paralel review** - Claude Code 2 model çalıştırır (Fable + Sonnet), Copilot CLI 3 (GPT-5.4 + Opus + Sonnet) - ve bir **Fable triage** sadece aksiyon alınabilir bulguları tutar; blocker'lar Phase 3'e geri döner.
+- **4 · Review** - önce deterministik kapılar (build / lint / test / secret-scan) geçmeli, sonra bir **CLI-farkında paralel review** - Claude Code 3 model çalıştırır (Fable + Opus + Sonnet), Copilot CLI 3 (GPT-5.4 + Opus + Sonnet) - ve bir **Fable triage** sadece aksiyon alınabilir bulguları tutar; blocker'lar Phase 3'e geri döner.
 - **5 · Test** - build + suite'i çalıştır; başarı zorunlu (sahte pass yok).
 - **6 · Commit/PR** - conventional commit, push (başarılı olmalı), bir PR aç (`Ref: #N`, asla otomatik kapatma).
 - **7 · Report** - teknik özet + test senaryolarıyla bir Jira yorumu, channels katmanından gönderilir.
 
+`/multi-agent:analysis` kendi kısa zincirini koşar ve v16.12.0'dan beri yazdığını yayınlamadan önce review ediyor: taslak, bir kod diff'iyle aynı üç-reviewer setinden ve triyajdan geçiyor, bloklayıcı bulgu dokümanı sentez fazına geri gönderip dispatch'i kapatıyor, hayatta kalan boşluklar ya aranıyor ya sana soruluyor ya da sahibiyle birlikte kayda giriyor. Önceden yalnızca yapısal bir validator'ın arkasından yayınlıyordu.
+
 Perde arkasında: her görev kendi **git worktree**'sinde çalışır (ya da `:local` ile mevcut branch'te), commit'ler **repo'nun origin URL'inden yönlendirilen git kimliğini** kullanır, ve **çoklu-repo** görevleri repo başına worktree artı bir integration build alır. Tokenlar OS keychain'de kalır; hiçbir şey commit edilmez ya da loglanmaz. `/multi-agent:review` mevcut bir GitHub/Bitbucket PR'ını da review edebilir - `file:line`'a bağlı bulgu-başına inline yorumlar + açık bir Approve / Needs-Work durumu.
 
 Bunun arkasındaki disiplin - sınırlı loop'lar, kanıt kapıları, token-bütçeli faz dokümanları, değişmez testler, taze-context handoff'lar - [docs/engineering.md](./docs/engineering.md)'de kataloglanmıştır. Tam özellik listesi [docs/features.md](./docs/features.md)'te. Bu repo, `multi-agent-plugins` marketplace'i ve `multi-agent-toolkit-mcp` sunucusunun install zamanında ve run zamanında nasıl bir araya geldiği [docs/ecosystem.md](./docs/ecosystem.md)'de diyagramlanmıştır.
@@ -87,7 +89,7 @@ Koşunun kendisinde ayarlanabilen tek şey derinlik, autopilot ve `--local`; ger
 
 ## Komutlar
 
-`/multi-agent` ve 53 alt komut. `/multi-agent:help` aynı katalogu terminalde, `outputLanguage` ayarına göre gösterir.
+`/multi-agent` ve 54 alt komut. `/multi-agent:help` aynı katalogu terminalde, `outputLanguage` ayarına göre gösterir.
 
 ### Pipeline girişleri
 
@@ -206,13 +208,13 @@ Bu, ilgili plugin'i (+ ortak `ai-common` plugin'ini) repo'nun `.claude/settings.
 
 ## Araç desteği
 
-Pipeline **Claude Code**, **Copilot CLI** ve **Codex CLI** üzerinde native çalışır - üçü de aynı `pipeline/` kaynağından kurulur ve aynı 53 komutu alır.
+Pipeline **Claude Code**, **Copilot CLI** ve **Codex CLI** üzerinde native çalışır - üçü de aynı `pipeline/` kaynağından kurulur ve aynı 54 komutu alır.
 
 | Araç | Bayrak | Ne kurar |
 |---|---|---|
 | Claude Code | `--claude` (varsayılan) | slash komutları + skill'ler + agent'lar + `PreToolUse` secret-scan hook'u |
-| Copilot CLI | `--copilot` | talimatlar + 53 alt-komut skill'i + script'ler |
-| Codex CLI | `--codex` | bir router skill + ref olarak 53 spec + 8 agent TOML + `AGENTS.md` bloğu + `codex mcp add` |
+| Copilot CLI | `--copilot` | talimatlar + 54 alt-komut skill'i + script'ler |
+| Codex CLI | `--codex` | bir router skill + ref olarak 54 spec + 8 agent TOML + `AGENTS.md` bloğu + `codex mcp add` |
 
 Skill'leri stack'e göre filtrele: `--platform=ios\|android\|all`.
 
@@ -224,8 +226,8 @@ pipeline tek bir `multi-agent` router gönderir ve alt-komut spec'lerini, okunan
 hiçbir maliyeti olmayan referans dosyaları olarak tutar - aynı komutlar, aynı davranış,
 host'un gerçekten tutabildiği bir düzen.
 
-Reviewer setleri farklı çünkü mevcut modeller farklı: Claude Code 2 reviewer çalıştırır
-(Fable + Sonnet), Copilot CLI 3 (Opus + GPT-5.4 + Sonnet), Codex CLI 3 (xhigh'da
+Reviewer setleri farklı çünkü mevcut modeller farklı: Claude Code 3 reviewer çalıştırır
+(Fable + Opus + Sonnet), Copilot CLI 3 (Opus + GPT-5.4 + Sonnet), Codex CLI 3 (xhigh'da
 gpt-5.6, gpt-5.4, medium'da gpt-5.6). Codex tek-vendor olduğu için üçü arasındaki
 konsensüs, iki-vendor'lu bir host'taki aynı konsensüsten daha zayıf bir kanıttır ve
 triage notu bunu belirtir.

package/docs/adr/0001-three-model-triage.md

@@ -2,6 +2,11 @@
 
 **Status:** Accepted · 2025 · Amended 2026-04 (CLI-aware reviewer set) · Amended 2026-07 (v10.6.0: Fable 5 restored - Reviewer 1 and triage run on Fable on Claude Code; Copilot CLI pins Opus. "Opus" below reads as "the top tier of the day")
 
+> **Superseded in part, v16.12.0.** The reviewer count is now 3 on every host: Opus
+> fills the slot GPT-5.4 occupies on Copilot and Codex, so Claude Code runs
+> Fable + Opus + Sonnet. The reasoning below about a 2-reviewer set on Claude Code
+> is kept as the record of what was decided then, not as current behaviour.
+
 ## Context
 
 Code review is the phase where the pipeline most commonly ships wrong work. A

package/docs/adr/0010-own-code-graph.md

@@ -0,0 +1,129 @@
+# 10. Our own code graph, not a forked one
+
+**Status:** Accepted · 2026-08-28
+
+## Context
+
+Two parts of the pipeline were paying for the same missing capability.
+
+Phase 1 dispatches parallel Explore agents that re-scan the repository with
+grep and read on every task, and `phase-1-analysis.md` makes the "very
+thorough" tier the default for feature, refactor and component work. Phase 7
+writes `~/.claude/knowledge/<project>/architecture.md` with an LLM, from the
+narrow window of whatever task happened to run, and the file is treated as
+stale after 90 days.
+
+Both want the same thing: a cheap, current answer to "where does this live"
+and "what depends on this".
+
+`Graphify-Labs/graphify` is a public reference that solved this and, unlike
+most projects in the space, published numbers for it. Its `BENCHMARKS.md`
+measures a fixed coding agent on ERPNext (~1M lines) over a graded question
+set: key-fact coverage rises from 70.8% on a grep-and-read baseline to 82.0%
+with a graph tool, at ~140K tokens per query, n=6. The baseline it beats is
+our Phase 1.
+
+The obvious move was to adopt it. Two things ruled that out. Its extraction
+is built on tree-sitter, which is a native npm runtime dependency and
+therefore forbidden by ADR-0004. And depending on an external repository for
+a capability this central puts the pipeline's core behaviour outside our
+control.
+
+## Decision
+
+Build the capability inside the pipeline, taking graphify as a design
+reference and not as a code source.
+
+Adopted from it: extraction is deterministic and LLM-free; the artifact is a
+single `graph.json` of typed nodes and edges; hub ("god-node") ranking is the
+highest-signal line of the report; queries are token-budgeted traversals
+rather than neighbourhood dumps; reverse traversal answers impact; and the
+measurement methodology is a graded question set against a grep-and-read
+baseline with the same cost accounting on both arms.
+
+Not adopted: tree-sitter (ADR-0004), LLM-named communities (the pipeline
+already has model routing for that), an MCP server (we ship our own toolkit),
+and its multi-platform installers and hooks.
+
+The engine is `pipeline/scripts/_code-graph.mjs`, with per-stack rules in
+`pipeline/scripts/code-graph-rules/<stack>.json`, five entry points
+(`graph-build`, `graph-query`, `graph-affected`, `graph-report`,
+`validate-code-graph`), a schema at `pipeline/schemas/code-graph.schema.json`,
+and the `/multi-agent:graph` command. It is off by default behind
+`prefs.global.codeGraph.enabled`.
+
+## What we deliberately gave up
+
+Regex over comment-stripped source is not a parser. Definitions and imports
+survive that trade; call graphs and type resolution do not. Two further limits
+follow from the same choice and are documented in the command rather than
+hidden:
+
+- A reference resolves only when a name maps to exactly one declaration. A
+  type declared in two files is dropped rather than fanned out to both, so
+  `affected` under-reports on duplicated names.
+- Only type-like symbols are reference targets. An early build let functions
+  be targets and the hub list filled with `with`, `localized`, `size` and
+  `name`: a bare lowercase name matched across files is almost never a call to
+  that exact declaration. The same measurement was repeated per stack rather
+  than assumed: on this repo, including JavaScript functions put `ok` at degree
+  52 and `f` at 38.
+- A nested declaration is a node but never a reference target. Sealed
+  hierarchies name their cases after the concept they model - `Icon`, `Color`,
+  `Success` - and each is declared exactly once, so the ambiguity rule does not
+  catch them. Before this rule, every Kotlin file that merely mentioned the
+  framework's `Color` gained an edge to one app's nested case: 4,072 false
+  edges out of 74,969.
+
+## Measurement
+
+Gated on a large private Swift app: 4,290 sources, 29,212 nodes, 54,626 edges,
+built in 3.2s, validator clean. Build time is dominated by reading the tree, so
+a repo whose files are not in the page cache costs more: the first build of the
+4,229-file Kotlin app took 18.2s and every later one 2.4-3.4s. Ten graded questions, both arms capped at a
+30,000-token retrieval budget, ground truth derived by grep and path match so
+that the impact family is stacked against the graph on purpose.
+
+| Arm | Coverage | Tokens/question |
+|---|---|---|
+| grep + read | 66.0% | 24,555 |
+| code graph | 80.4% | 18,465 |
+
+The aggregate passes the gate, but the split is the useful part. On questions
+naming an exact type, `grep -lw` is the oracle: it scored 100% and the graph
+was marginally worse and marginally more expensive. On questions phrased in
+domain words, the graph scored 63.3% against 32.0% at 10,937 tokens against
+24,983. The value is in narrowing an open-ended search, not in replacing a
+grep for a name you already know.
+
+That measurement covers the context each strategy assembles, not the quality
+of an answer written from it. graphify's numbers measure the latter. The two
+are not directly comparable and this ADR does not claim they are.
+
+## Consequences
+
+Positive:
+
+- No new runtime dependency; ADR-0004 holds.
+- Graph construction costs no API tokens, so Phase 7 can refresh it every run
+  instead of ageing an LLM-written file for 90 days.
+- Staleness becomes a commit comparison rather than a date heuristic.
+- Every stack after the first is one rules file. Bringing up Kotlin, Python
+  and JavaScript needed two engine changes, and both were engine defects that
+  iOS had been getting away with rather than stack requirements: nesting was
+  measured from the pattern's match column, so `public final class Foo` read as
+  nested, and the import pass read a fully stripped body, which blanks a
+  JavaScript module specifier because it is a string literal. iOS was re-gated
+  after both and scored identically.
+
+Negative:
+
+- Accuracy is bounded by regex extraction and will stay below what a parser
+  would give.
+- Each supported stack carries a hand-written rules file that has to keep up
+  with its language.
+- The symbol layer is thin on stacks whose exported unit is a function. On
+  Node the useful graph is the import graph between files, and the command
+  says so rather than implying a richness the stack does not have.
+- A 4,300-file repo produces a ~22MB JSON file. It is read whole on every
+  query; that is fine at this scale and is not proven at ten times it.

package/docs/adr/README.md

@@ -19,6 +19,7 @@ Format: lightly adapted from [Michael Nygard's ADR template](https://cognitect.c
 | [0007](./0007-multi-tool-adapter-framework.md) | Multi-tool adapter framework + token-preserving uninstall | Superseded by v10.7.0 (adapters removed; Claude Code + Copilot CLI only) |
 | [0008](./0008-installer-modularization-and-secret-leak-defense.md) | Installer modularization + secret-leak defense | Accepted (amended v10.7.0: adapter module removed) |
 | [0009](./0009-claude-stack-skills-plugin-only.md) | Claude Code stack skills are plugin-only; local copy retired | Accepted (supersedes ADR-0006 install-destination clause) |
+| [0010](./0010-own-code-graph.md) | Own code graph, referenced from graphify, not forked | Accepted |
 
 ## Writing a New ADR
 

package/docs/architecture.md

@@ -117,7 +117,7 @@ graph TB
     end
 
     subgraph "Pipeline Specs"
-        CMD[commands/<br/>53 command files]
+        CMD[commands/<br/>54 command files]
         AGT[agents/<br/>8 agent personas]
         RUL[rules/<br/>12 domain rules]
         PHS[multi-agent-refs/phases/<br/>phase specs + contracts]
@@ -170,7 +170,7 @@ revisions of this diagram - Codex CLI and the two independently-shipped repos
 graph TD
     CC["Claude Code<br/>(source of truth)"]
     COP["Copilot CLI<br/>(instructions + 51 skills)"]
-    COD["Codex CLI<br/>(1 router skill + 53 refs)"]
+    COD["Codex CLI<br/>(1 router skill + 54 refs)"]
     REPO["Pipeline Repo<br/>(npm package)"]
     WEB["Website"]
     PLUGREPO["multi-agent-plugins<br/>(5 stack plugins, own repo)"]

package/docs/ecosystem.md

@@ -5,7 +5,7 @@ separately, wired together at install time and at run time:
 
 | Repo | What it owns | Ships as |
 |---|---|---|
-| **`multi-agent-pipeline`** (this repo) | Orchestration: the 8-phase flow, the 53 slash commands, quality gates, review/triage, cross-CLI parity | npm package (`@mmerterden/multi-agent-pipeline`), installs itself onto Claude Code / Copilot CLI / Codex CLI |
+| **`multi-agent-pipeline`** (this repo) | Orchestration: the 8-phase flow, the 54 slash commands, quality gates, review/triage, cross-CLI parity | npm package (`@mmerterden/multi-agent-pipeline`), installs itself onto Claude Code / Copilot CLI / Codex CLI |
 | **`multi-agent-plugins`** | Stack knowledge: per-platform component/lifecycle skills (iOS, Android, Frontend, Backend) + shared knowledge | Claude Code marketplace, 5 independently-versioned plugins |
 | **`multi-agent-toolkit-mcp`** | The pipeline's hands on devices and browsers: 80 MCP tools across 6 categories (simulator/emulator control, accessibility audit, store compliance, web automation, Figma-vs-mock design audit, an agent-DSL batch runner) | npm package, registered as a standard stdio MCP server on every host |
 
@@ -18,7 +18,7 @@ Either can be swapped or removed without touching the other two's source.
 graph LR
     subgraph PIPE ["multi-agent-pipeline (orchestrator)"]
         direction TB
-        PHASES["8 phases · 53 commands"]
+        PHASES["8 phases · 54 commands"]
         GATES["deterministic gates + review triage"]
     end
 
@@ -64,8 +64,8 @@ only those:
 graph TD
     CC["Claude Code<br/>~/.claude/commands/multi-agent/<br/>(source of truth)"]
 
-    CC -->|"Step 2: copy + reformat<br/>53 sub-command skills"| COP["Copilot CLI<br/>~/.copilot/skills/"]
-    CC -->|"Step 2b: transform<br/>(install.js --codex)"| COD["Codex CLI<br/>1 router skill + 53 refs<br/>+ 8 agent TOML"]
+    CC -->|"Step 2: copy + reformat<br/>54 sub-command skills"| COP["Copilot CLI<br/>~/.copilot/skills/"]
+    CC -->|"Step 2b: transform<br/>(install.js --codex)"| COD["Codex CLI<br/>1 router skill + 54 refs<br/>+ 8 agent TOML"]
     CC -->|"Step 3: genericize<br/>(strip personal data)"| REPO["multi-agent-pipeline repo<br/>pipeline/"]
     CC -->|"Step 4: version + feature sync"| WEB["Website<br/>projects.ts / i18n.tsx"]
 
@@ -153,7 +153,7 @@ measurements behind this table):
 
 | | Claude Code | Copilot CLI | Codex CLI |
 |---|---|---|---|
-| **Pipeline commands** | 53 slash-command skills, native | 53 skills, `multi-agent-{cmd}` naming, copied in | 1 router skill (`multi-agent`) + 53 command specs as reference files - Codex silently truncates its skills block past a few dozen entries, so sub-commands are not peer skills here |
+| **Pipeline commands** | 54 slash-command skills, native | 54 skills, `multi-agent-{cmd}` naming, copied in | 1 router skill (`multi-agent`) + 54 command specs as reference files - Codex silently truncates its skills block past a few dozen entries, so sub-commands are not peer skills here |
 | **Stack plugins** | Marketplace plugin, loaded natively, resolved by `.claude/settings.json` enabled-list | Enabled plugin's authored skills copied flat into `~/.copilot/skills/`; `knowledge/` **not** re-copied (already delivered via `shared/external`) | Copied as reference files under `~/.codex/multi-agent-refs/skills/`, plugin-prefixed on name clash (e.g. `architecture` → `ai-ios-toolkit-architecture`) |
 | **Component dispatch (Phase 3)** | Marketplace plugin's `create-component`/`create-screen` skill via the Skill tool | No plugin loader - the enabled stack plugin's authored skills (incl. `create-component`) are copied flat into `~/.copilot/skills/` at install time (the old frozen `figma-*` copies are pruned, they were never a fallback) | Not part of the enforced parity axis; classification + state-shape must match, skill *inventory* does not |
 | **multi-agent-toolkit-mcp** | `claude mcp add multi-agent-toolkit -- npx -y @mmerterden/multi-agent-toolkit-mcp` | `copilot mcp add multi-agent-toolkit -- npx -y @mmerterden/multi-agent-toolkit-mcp` | `codex mcp add multi-agent-toolkit -- npx -y @mmerterden/multi-agent-toolkit-mcp` (skipped with a warning if `codex` isn't on `PATH`) |

package/docs/features.md

@@ -12,7 +12,7 @@ Phase 1: Analysis  Stack detection, codebase exploration (parallel Explore agent
 Phase 2: Planning  Task decomposition, architecture review, user approval
 Phase 3: Dev       TDD cycle: test → code → build (Sonnet)
 Phase 4: Review    Deterministic gates + parallel AI review + Fable triage
-                   (Claude Code: Fable + Sonnet · Copilot CLI: GPT-5.4 + Opus + Sonnet)
+                   (Claude Code: Fable + Opus + Sonnet · Copilot CLI: GPT-5.4 + Opus + Sonnet)
 Phase 5: Test      Optional manual testing + on-demand device audits
 Phase 6: Commit    Git commit, push, PR with default reviewers + draft/ready prompt
 Phase 7: Report   External: Jira comment · Wiki + Figma screenshots · Confluence
@@ -40,6 +40,14 @@ The install is not only useful while `/multi-agent` is running. `rules/outside-t
 
 Uninstall preserves the whole layer - tokens, the reader that opens them, the mapping that names them, the MCP registration. It is 1.5 kB of always-loaded text; the detail lives in a ref that loads on demand, and a gate keeps both under a ceiling because every byte there is paid by every session.
 
+### Code Graph (`/multi-agent:graph`, opt-in)
+
+A deterministic, LLM-free map of what a repo declares and what refers to what, extracted by regex over comment-stripped source into `~/.claude/knowledge/<project>/code-graph.json`. Four stacks build today (Swift, Kotlin/Java, TypeScript/JavaScript, Python); each is one rules file, and the engine is the same for all of them. Zero runtime dependencies, zero API cost, read-only on the repo.
+
+Phase 1 queries it to hand Explore a ranked starting file set instead of a full scan, and Phase 7 rebuilds it after the branch changed code - a rebuild is seconds, so staleness is a `baseCommit` comparison rather than a date heuristic. Off by default behind `prefs.global.codeGraph.enabled`; with it off the pipeline behaves exactly as before.
+
+Measured on a 4,300-file Swift app against a grep-and-read baseline at the same 30,000-token retrieval budget: 80.4% key-fact coverage at 18,465 tokens against 66.0% at 24,555. The gain is entirely in searches phrased in domain words (63.3% against 32.0%, at under half the cost). When the task already names an exact type, `grep -lw` is still slightly better and slightly cheaper, and the command says so rather than overselling. Reasoning, trade and limits: `docs/adr/0010-own-code-graph.md`.
+
 ### Stack Auto-Detection
 
 | Platform       | Detection                                    | Guide Loaded             |
@@ -134,6 +142,22 @@ Cheap, objective checks run BEFORE any AI token is spent:
 
 If any gate fails, fix first. Don't waste AI tokens reviewing broken code.
 
+### Analysis Document Review (Phase 3.2 + 3.3)
+
+`/multi-agent:analysis` published behind a structural validator alone until v16.12.0: nothing read the
+document before it reached Confluence. Phase 3.2 now runs the same reviewer set and triage a code diff
+gets, on the draft, before the destination is even chosen. Its first question is what the run skipped -
+an input declared missing that nothing searched for, an open question about evidence nobody read, a gap
+with no owner, a scope call made without asking. A blocking finding returns to synthesis with dispatch
+closed; it never becomes an open question, because "the document is wrong" is not something to ask the
+reader.
+
+Phase 3.3 then sorts what is left: reachable evidence is searched (never asked about), decisions the
+user owns are asked with `AskUserQuestion`, and only genuinely external gaps enter the document as
+`AS-NN` rows with an owner. A gap carrying neither a `searched, not found` nor an `asked, external`
+stamp fails the dispatch gate. Autopilot runs both phases; only the asking degrades, into rows stamped
+`autopilot: could not ask`.
+
 ### CLI-Aware Parallel Review + Fable Triage (Phase 4 Steps 2-3)
 
 | Reviewer   | Model               | Focus                             | Where it runs        |
@@ -142,7 +166,7 @@ If any gate fails, fix first. Don't waste AI tokens reviewing broken code.
 | Reviewer 2 | `gpt-5.4`           | Edge cases, different perspective | **Copilot CLI only** |
 | Reviewer 3 | `claude-sonnet-4-6` | Quality + correctness + naming    | Both CLIs            |
 
-The reviewer set is **CLI-aware**: Claude Code dispatches 2 reviewers in parallel (Fable + Sonnet - GPT-5.4 is not available there); Copilot CLI dispatches all 3. Each returns structured JSON for deterministic aggregation. Cross-model diversity catches blind spots that any single model family would miss.
+The reviewer set is **CLI-aware**: Claude Code dispatches 3 reviewers in parallel (Fable + Opus + Sonnet - Opus fills the slot GPT-5.4 takes elsewhere); Copilot CLI dispatches all 3. Each returns structured JSON for deterministic aggregation. Cross-model diversity catches blind spots that any single model family would miss.
 
 **Fable Triage** (Phase 4 Step 3, Opus on Copilot CLI): Evaluates merged raw findings against task scope. Classifies each as `accepted` (fix now), `deferred` (out of scope, log for later), or `rejected` (false positive / noise). Only triage-accepted blocking items loop back to Phase 3.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmerterden/multi-agent-pipeline",
-  "version": "16.11.0",
+  "version": "16.13.0",
   "description": "8-phase AI development pipeline with full orchestration on Claude Code, Copilot CLI and Codex CLI. Analysis, planning, TDD, CLI-aware parallel review with consensus surfacing + Fable triage, default-FAIL evidence gates, secret + intent guards, per-phase cost ledger, persistent learnings memory, wiki generation, commit automation. Token-preserving uninstall.",
   "type": "module",
   "main": "index.js",

package/pipeline/claude-md-template.md

@@ -17,7 +17,7 @@
 2. Planning (Opus) -> spec, task breakdown
 3. Development (Sonnet) -> TDD, code, build
 4. Review -> deterministic gates + parallel review + Fable triage
-   - Claude Code: Opus + Sonnet (2 paralel)
+   - Claude Code: Fable + Opus + Sonnet (3 paralel)
    - Copilot CLI: GPT-5.4 + Opus + Sonnet (3 paralel)
    - Codex CLI: gpt-5.6 (xhigh) + gpt-5.4 + gpt-5.6 (medium) (3 paralel)
 

package/pipeline/commands/multi-agent/SKILL.md

@@ -1,6 +1,6 @@
 ---
 description: "Task orchestrator  -  full pipeline via Jira ID + branch or GitHub Issue URL: analysis, plan, TDD development, parallel review + Fable triage (CLI-aware: 2-model on Claude Code, 3-model on Copilot CLI), commit, log. Use when given a Jira ID, a GitHub issue or a free-text task and the whole pipeline should run."
-description-tr: "Görev orkestratörü - Jira ID + branch veya GitHub Issue URL ile tam pipeline: analiz, plan, TDD geliştirme, paralel review + Fable triyajı (CLI'ya göre: Claude Code'da 2, Copilot CLI'da 3 model), commit, log"
+description-tr: "Görev orkestratörü - Jira ID + branch veya GitHub Issue URL ile tam pipeline: analiz, plan, TDD geliştirme, paralel review + Fable triyajı (CLI'ya göre: Claude Code'da 3, Copilot CLI'da 3 model), commit, log"
 allowed-tools: Agent, Bash, Read, Write, Edit, Glob, Grep, TaskCreate, TaskUpdate, TaskList, TaskGet, AskUserQuestion, WebFetch, WebSearch, NotebookEdit, Skill
 ---
 

package/pipeline/commands/multi-agent/analysis/SKILL.md

@@ -61,7 +61,7 @@ Full contract: `$HOME/.claude/multi-agent-refs/analysis/evidence.md`. Fetches ev
 
 Full contract: `$HOME/.claude/multi-agent-refs/analysis/synthesis.md`. Pass A builds the platform-agnostic concept layer; Phase 2a previews the resolved conventions for approval (Locked 26); Pass B projects each concept onto the selected platform with a footnote per filled cell (Locked 24).
 
-### Phases 3, 3.5, 4, 5 - Render, publish, report
+### Phases 3, 3.2, 3.3, 3.5, 4, 5 - Render, review, publish, report
 
 Full contract: `$HOME/.claude/multi-agent-refs/analysis/render.md`. Renders one markdown file per platform, runs the **required** `ai-common-toolkit:humanizer` pass, gates on `validate-analysis-doc.mjs` and on the `build-references.mjs --check` references coverage gate (Locked 34), asks for the output destination, dispatches to Local / Confluence / Jira (a Jira issue receives a comment unless the user explicitly asks for the description, which is never overwritten without a backup and a confirmation), then reports and stops. The humanizer pass and the validator are required in every mode; a document that skipped either is not shippable.
 

package/pipeline/commands/multi-agent/graph/SKILL.md

@@ -0,0 +1,105 @@
+---
+description: "Build and query this repo's code graph: a deterministic, LLM-free map of symbols, imports and references used to narrow Phase 1's Explore scope and to keep the knowledge base current. Read-only on code, costs no API tokens. Use when a task needs to know where something lives or what depends on it before reading files."
+description-tr: "Bu repo'nun kod grafiğini kurar ve sorgular: sembolleri, import'ları ve referansları LLM'siz, deterministik biçimde haritalar. Faz 1'in Explore kapsamını daraltmak ve bilgi tabanını güncel tutmak için kullanılır. Kodda salt-okunur, API maliyeti yok."
+argument-hint: "[build | refresh | ask \"<question>\" | affected \"<symbol>\" | report | status]"
+---
+
+# multi-agent graph  -  code graph build and query
+
+**Input**: $ARGUMENTS
+
+A code graph is a map of what this repo declares and what refers to what, built by
+regex over comment-stripped source. It exists so Phase 1 can narrow its Explore
+fan-out and Phase 7 can refresh `~/.claude/knowledge/<project>/` without an LLM
+pass. It answers "where does this live" and "what depends on this". It does not
+answer "what calls this at runtime": call graphs and type resolution need a real
+parser, which would be an npm runtime dependency, and ADR-0004 forbids one.
+
+No worktree, no branch, no commit, no pipeline chaining.
+
+## Sub-commands
+
+| Input | Runs | Notes |
+|---|---|---|
+| `build` | `graph-build.mjs --root <repo> --stack <stack>` | Writes `~/.claude/knowledge/<project>/code-graph.json` |
+| `refresh` | same as `build` | A full rebuild takes seconds, so there is no separate incremental path |
+| `ask "<question>"` | `graph-query.mjs "<question>" --budget N` | Token-budgeted traversal; default budget 2000 |
+| `affected "<symbol>"` | `graph-affected.mjs "<symbol>" --depth N` | Reverse traversal: the blast radius of a change |
+| `report` | `graph-report.mjs` | Writes `GRAPH_REPORT.md` beside the graph |
+| `status` | `graph-report.mjs --status` | One line: stack, scale, build time and whether `baseCommit` still matches HEAD. Never read the graph file yourself - it is 22MB on a large repo |
+
+With no argument, run `status`, then offer `build` when no graph exists and
+`refresh` when `baseCommit` differs from the current HEAD.
+
+## Steps
+
+1. **Resolve the repo.** `PROJECT_ROOT` is the current repo root unless the user
+   named another. Derive the graph path once and pass it to every call below:
+
+   ```bash
+   GRAPH_PATH="$HOME/.claude/knowledge/$(basename "$PROJECT_ROOT")/code-graph.json"
+   ```
+
+   The query, affected and report scripts default that path from the CWD's
+   basename, which is not the same thing when the shell sits in a worktree or a
+   sub-package, so a defaulted path can point at a graph that was never built.
+
+2. **Resolve the stack.** Read `state.detectedStack` when a run is in flight;
+   otherwise detect from project markers the way Phase 1 Step 2 does. Only stacks
+   with a file in `$HOME/.claude/scripts/code-graph-rules/` can be built. A stack with
+   no rule file is reported as unsupported, never guessed at.
+
+3. **Run the sub-command.** Every script is read-only on the repo and writes only
+   under `~/.claude/knowledge/`:
+
+   ```bash
+   node $HOME/.claude/scripts/graph-build.mjs --root "$PROJECT_ROOT" --stack "$STACK" --out "$GRAPH_PATH"
+   node $HOME/.claude/scripts/graph-query.mjs "<question>" --graph "$GRAPH_PATH" --budget 2000
+   node $HOME/.claude/scripts/graph-affected.mjs "<symbol>" --graph "$GRAPH_PATH" --depth 2
+   node $HOME/.claude/scripts/graph-report.mjs --graph "$GRAPH_PATH"
+   node $HOME/.claude/scripts/graph-report.mjs --graph "$GRAPH_PATH" --status
+   ```
+
+4. **Validate after a build.** A graph that parses but whose edges point at
+   missing nodes yields silently truncated traversals, so the build is not
+   reported as successful until the validator agrees:
+
+   ```bash
+   node $HOME/.claude/scripts/validate-code-graph.mjs "$GRAPH_PATH"
+   ```
+
+   A non-zero exit fails CLOSED: report the validator's `errors[]` verbatim and
+   do not record the graph as usable.
+
+5. **Report.** One line for a build (`files / nodes / edges / elapsed`), the
+   traversal output as-is for `ask` and `affected`, the report path for `report`.
+
+## What the output is for
+
+`ask` returns ranked nodes plus their neighbourhood within a token budget. Feed
+it to an Explore agent as the starting file set rather than pasting it into a
+final answer: it is a search result, not an explanation.
+
+`affected` returns dependents, which is what `analysis.touchedAreas[]` wants.
+
+## Limits worth stating when reporting
+
+- References resolve only when a name maps to exactly one declaration. A type
+  declared in two files is ambiguous and is deliberately dropped, so `affected`
+  under-reports for duplicated names rather than fanning out to every candidate.
+- Only type-like symbols are reference targets. Functions appear in the graph
+  through their declaring file, not as targets, because a bare lowercase name
+  matched across files is almost never a call to that exact declaration.
+- Comments and string literals are stripped before extraction, so a name that
+  appears only in prose or in a string produces no edge.
+- A nested declaration is a node but never a reference target. A Kotlin sealed
+  case or a Python inner class named `Icon` or `Color` is declared exactly once,
+  so the ambiguity rule above does not catch it, and every file that merely
+  mentions the framework type of that name would otherwise gain an edge to it.
+- On stacks whose exported unit is a function (Node most of all) the symbol
+  layer is thin by design and the import graph between files carries the value.
+  Ask `affected "<file>.mjs"` there, not `affected "<functionName>"`.
+- `affected` at `--depth 1` returns direct symbol references only. An import
+  whose module name matches a declaring file's basename reaches the symbol
+  through that file, so its importers appear at depth 2. Keep the default
+  depth of 2 unless direct references are what you actually want.