thurview 0.17.2 → 0.19.0

package/README.md

@@ -23,13 +23,14 @@ _The reader's half of it; the agent is working off camera._
   agent — at once if one is listening, queued if not — and the answer lands
   in the same thread; a comment waits for your decision. Then you approve the
   change or send it back with the comments attached.
-- **A code graph answers what the diff cannot.** Who calls the symbol that
-  moved, which tests reach it, where the change landed in the system and what
-  sits next to it. thurview builds the graph itself with tree-sitter from the
-  pinned commits, for TypeScript, JavaScript, Python, Go, Rust, Java and Elixir.
+- **The agent searches what the diff cannot show.** Who calls the symbol that
+  moved, which tests reach it, what imports the module it touched: the skills
+  give the agent `git grep` recipes run at the pinned commits, in any language,
+  and every claim that rests on a search carries the search, so you can run it
+  again.
 - **The evidence is checked, not taken on trust.** An anchor whose lines
   do not exist at the pinned commit, a call stack frame asserting a call the
-  diff does not show, an interface annotation for a symbol the change never
+  diff does not show, an interface entry anchored on lines the change never
   moved, a trust boundary crossing that resolves to nothing — publishing
   rejects each one rather than rendering it.
 
@@ -115,9 +116,8 @@ Install the command itself, rather than leaving the skills to reach it through
 npm install -g thurview     # or: pnpm add -g thurview
 ```
 
-Nothing else needs installing: the code graph is built from the pinned commits
-with tree-sitter. `thurview graph` answers which interfaces the change moved,
-what it reaches, who calls a symbol, what tests cover it and how files cluster.
+Nothing else needs installing beyond `git`: callers, tests and importers are
+found by the agent's own search at the pinned commits.
 
 To run from a checkout instead:
 
@@ -224,13 +224,21 @@ Approve, or send it back with the comments:
 ![The submit dialog, one pending comment, Approve or Request
 changes](./media/review-decision.png)
 
+To share a document with someone who will not run thurview,
+`thurview export --out review.html` writes the published revision as one HTML
+file: the same page, read only, with every snippet, diagram and diff resolved
+at the pinned commits and the reader's threads shown as notes (`--no-threads`
+leaves them out). It opens from disk, fetches nothing, and names no server and
+no local path. Point `--out` at a folder for `<folder>/index.html`, such as a
+repository's Pages folder.
+
 ## What's in a review
 
 - **Interface delta**: above the document, what the change added to, changed
   in or removed from the surfaces other code can reach - exported functions
-  and types, plus the CLI flags, routes, config keys and formats the agent
-  declares. Derived from the code graph at both pinned commits, so a change
-  that moved no surface says exactly that instead of inventing a feature.
+  and types, CLI flags, routes, config keys and formats. The agent declares
+  each one, and publish holds it to an anchor on lines the diff really moved,
+  so an entry cannot invent a feature the change did not deliver.
 - **Review**: the document with a table of contents. Anchor links open the
   exact code beside the text; peeks show it inline. Sequence diagrams, call
   stack diffs and storage views are clickable down to the line.
@@ -240,11 +248,11 @@ changes](./media/review-decision.png)
   jumps there.
 - **Commits**: the commits between base and head.
 - **Coverage** (explainers): every file in scope at the pinned commit, in one
-  of three states - anchored in the document, placed on the map only, or not
-  examined - with the parts of the system they belong to, the references that
-  cross between those parts, and the names defined in more than one of them.
-  Derived at publish, so what the explainer skipped is a stated fact rather
-  than something the reader has to infer.
+  of four states - anchored in the document, placed on the map only, matched
+  by a search the agent recorded, or not examined - grouped by directory, with
+  each search and what it matched. Derived at publish, which re-runs every
+  recorded search with `git grep` at the pinned commit, so what the explainer
+  skipped is a stated fact rather than something the reader has to infer.
 - **Map**: systems, containers, components and code, with what the change
   added, removed or touched, linked to files and code.
 - **Threads**: _Send to the agent_ delivers a question at once and the answer
@@ -268,21 +276,21 @@ bar.
 
 ## CLI
 
-| Command                                                               | Purpose                                                               |
-| --------------------------------------------------------------------- | --------------------------------------------------------------------- |
-| `thurview scaffold [--pr N \| --base R --head R]`                     | Create a review pinned to exact commits (`--update` re-pins)          |
-| `thurview explain [<path>] [--commit R]`                              | Create a code explainer of a codebase or subsystem at one commit      |
-| `thurview design [<path>] [--commit R]`                               | Create a design of what to build, pinned to the commit it argues from |
-| `thurview info [--all]`                                               | Reviews, explainers and designs bound to this worktree                |
-| `thurview publish --review ID [--view T] [--open]`                    | Validate the document and map, seal a revision                        |
-| `thurview open --review ID [--view T]`                                | Start the server if needed and open the browser                       |
-| `thurview wait --review ID [--timeout S]`                             | Block until the reader needs the agent                                |
-| `thurview threads list\|get\|reply\|resolve`                          | Read and answer threads                                               |
-| `thurview graph interfaces\|impact\|callers\|tests-for\|architecture` | Ask the code graph at a review's pins, or at `--base`/`--head`        |
-| `thurview forge status\|prior\|pass\|submit\|reply`                   | Read a change request through its forge, and post the review back     |
-| `thurview serve` / `thurview stop`                                    | Run the server in the foreground / stop the background one            |
-| `thurview setup hooks\|skill\|status`                                 | Session hooks, agent skill, install state                             |
-| `thurview update`                                                     | Self-update from npm                                                  |
+| Command                                                 | Purpose                                                               |
+| ------------------------------------------------------- | --------------------------------------------------------------------- |
+| `thurview scaffold [--pr N \| --base R --head R]`       | Create a review pinned to exact commits (`--update` re-pins)          |
+| `thurview explain [<path>] [--commit R]`                | Create a code explainer of a codebase or subsystem at one commit      |
+| `thurview design [<path>] [--commit R]`                 | Create a design of what to build, pinned to the commit it argues from |
+| `thurview info [--all]`                                 | Reviews, explainers and designs bound to this worktree                |
+| `thurview publish --review ID [--view T] [--open]`      | Validate the document and map, seal a revision                        |
+| `thurview open --review ID [--view T]`                  | Start the server if needed and open the browser                       |
+| `thurview export --review ID --out PATH [--no-threads]` | Write the published revision as one static HTML file, no server       |
+| `thurview wait --review ID [--timeout S]`               | Block until the reader needs the agent                                |
+| `thurview threads list\|get\|reply\|resolve`            | Read and answer threads                                               |
+| `thurview forge status\|prior\|pass\|submit\|reply`     | Read a change request through its forge, and post the review back     |
+| `thurview serve` / `thurview stop`                      | Run the server in the foreground / stop the background one            |
+| `thurview setup hooks\|skill\|status`                   | Session hooks, agent skill, install state                             |
+| `thurview update`                                       | Self-update from npm                                                  |
 
 thurview is an [AXI](https://axi.md): built for agents that drive it through a
 shell. Output is [TOON](https://toonformat.dev) on stdout, errors are
@@ -298,19 +306,19 @@ stderr.
 
 The `thurview-fix` skill reviews a branch, a commit range or a pull or merge
 request, fixes what it is sure of and reports the rest, with no browser and no
-approval step. For each changed symbol it asks the code graph who calls it and
-which tests reach it, so a finding can name a caller the diff never shows.
+approval step. For each changed symbol it searches, at the pinned commits, who
+calls it and which tests name it, so a finding can name a caller the diff never
+shows.
 Fixes that pass the repository's own tests and lint land as one local commit;
 nothing is pushed unless you ask.
 
 ```sh
-thurview graph impact --head HEAD                 # changed symbols, the callers they left alone, the tests
-thurview graph callers discount --head HEAD       # every call site of one symbol
+git grep -n -E -e '\bdiscount *\(' <head> --              # every call site of one symbol
+git grep -n -E -e '\bdiscount\b' <head> -- '*test*' '*spec*'  # the tests that name it
 ```
 
-`--base` and `--head` ask about two commits directly; `--head` alone diffs
-from where it forked from trunk. Each caller in `impact.reach` carries the line
-of its call and whether any test reaches it.
+Each finding carries the search behind it, so "no other caller" is a line you
+can run.
 
 With `--post`, the skill posts the findings it did not fix as inline comments
 on the change request, through `thurview forge`:
@@ -358,9 +366,10 @@ The agent writes three files in `~/.thurview/reviews/<id>/`:
   blocks `peek`, `sequence`, `flow`, `callstack` and `database` add components.
   `## Heading {collapsed}` folds a section by default.
 - `data.yaml`: typed inputs: `actors`, `anchors` (file, from, to, graph),
-  `stores`, `interfaces` (a capability line per derived entry, plus the
-  interfaces the graph cannot see), and `security`, where a review says where
-  the change lets input cross a trust boundary.
+  `stores`, `interfaces` (one entry per interface the change moved, each
+  anchored on the lines that moved it), `security`, where a review says where
+  the change lets input cross a trust boundary, and `searches`, where an
+  explainer records what it searched for its Coverage tab.
 - `map.yaml`: the software map at head, optionally at base. In an explainer it
   carries the breadth the prose has no room for, and a node's `files` globs are
   what let a file count as placed rather than not examined.
@@ -377,14 +386,14 @@ defined in one place — the `thurview-fix` skill's finding rules — and
 nothing else restates it.
 
 An explainer writes the same files, minus `interfaces` and `security`: there is
-no change to derive a delta from or to carry input across a boundary, and
+no change to take a delta from or to carry input across a boundary, and
 `graph: base` on an anchor is an error because there is one commit.
 
 A design writes the same files, and `interfaces` means something else in it:
 each entry is a **proposal** — what the design would add, change or remove,
 with the anchor of the code that proposal lands in, replaces or plugs into
 today. `graph: base` and `security` are errors for the same reason as in an
-explainer, a `symbol:` entry is an error because no diff derived one, and a
+explainer, `searches` is an error because a design has no Coverage tab, and a
 design that proposes nothing is refused: that document is an explainer. In its
 `map.yaml`, `base` is the structure as it stands and `nodes` the structure it
 proposes, so a proposed part may own files that do not exist yet while a `base`

package/dist/cli.js

@@ -11,13 +11,14 @@ import open from "open";
 import * as g from "./git.js";
 import { SCHEMA, home, newId, now, readReview, writeReview, listReviews, reviewsFor, reviewDir, revisionDir, passFile, readThreads, readText, writeText, writeJson, readJson, serverStateFile, deleteReview, kindOf, } from "./store.js";
 import { compileDocument, compileMap, globToRegExp } from "./document/compile.js";
-import { computeCoverage, scopeGlob, scopeGraph, scopeTruncated, } from "./coverage.js";
+import { computeCoverage, scopeGlob } from "./coverage.js";
 import { parseTheme, compileTheme } from "./theme.js";
 import { registerTheme } from "./highlight.js";
 import { replyThread, setThreadStatus, needsAgent } from "./threads.js";
 import { targetLabel, truncate } from "./thread-state.js";
 import { attach } from "./presence.js";
 import { startServer } from "./server/server.js";
+import { exportReview, localTarget } from "./export.js";
 import { parseFlags, helpFor, str, bool } from "./flags.js";
 import { forgeFor, repoOf, summariseCi, } from "./forge/index.js";
 import { parseSubmission, longComments, buildPass } from "./forge/submission.js";
@@ -205,9 +206,6 @@ async function ensureServer() {
 function reviewUrl(base, id, view) {
     return `${base}/review/${id}${view ? `#/${view}` : ""}`;
 }
-function pinnedOf(review) {
-    return { worktree: review.worktree, pins: review.pins, dir: reviewDir(review.id) };
-}
 /**
  * Base and head as `--base` and `--head` name them. Head defaults to HEAD and
  * base to where head forked from trunk, so a branch is diffed against what it
@@ -227,28 +225,6 @@ async function pinRange(worktree, base, head, usage) {
         ]);
     }
 }
-/**
- * The interface delta at two pinned commits. The graphs are cached per commit
- * under `at.dir`, so publish and `graph interfaces` build them once between
- * them; both modules load lazily to keep tree-sitter off every other command's path.
- */
-async function deltaFor(at, base, head) {
-    const graph = await import("./graph.js");
-    const { interfaceDelta } = await import("./interfaces.js");
-    const b = base ?? (await graph.graphAt(at.worktree, at.pins.base, at.dir));
-    const h = head ?? (await graph.graphAt(at.worktree, at.pins.head, at.dir));
-    const changes = await g.lineChanges(at.worktree, at.pins.base, at.pins.head);
-    const changed = await g.changedFiles(at.worktree, at.pins.base, at.pins.head);
-    return interfaceDelta({
-        cwd: at.worktree,
-        pins: at.pins,
-        base: b,
-        head: h,
-        impact: graph.impact(b, h, changes, 1),
-        changes,
-        changed,
-    });
-}
 async function guidanceFiles(repoRoot) {
     return [join(home(), "THURVIEW.md"), join(repoRoot, "THURVIEW.md")].filter((p) => existsSync(p));
 }
@@ -272,8 +248,13 @@ const TEMPLATE_DATA = `# Typed inputs for review.md: actors, anchors and stores.
 #     title: PTY spawn site
 #     peek: { file: src/pty.ts, from: 214, to: 223 }   # add graph: base for the old side
 #
-# interfaces holds one capability line per interface the change moved. thurview
-# derives the list itself; run \`thurview graph interfaces\` for the ids.
+# interfaces holds one entry per interface the change added, changed or removed:
+# a CLI flag, an exported function, an HTTP route, a config key. Name it, say what
+# it lets a consumer do, and anchor it on the lines that moved it (a base-side
+# anchor for a removed one). Find what depends on it with git grep at the pins.
+#
+# interfaces:
+#   shellFlag: { name: --shell, change: added, capability: Runs in the named shell., anchor: spawn }
 #
 # security says where this change lets input cross a trust boundary. Leave it
 # out (or write \`security: pending\`) until you have looked and the document says
@@ -324,14 +305,23 @@ const TEMPLATE_EXPLAIN_DATA = `# Typed inputs for the explainer: actors, anchors
 #   dispatch:
 #     title: where a request picks its handler
 #     peek: { file: src/server/router.ts, from: 41, to: 58 }
+#
+# searches records the searches you ran to find callers, tests and importers.
+# publish re-runs each one with \`git grep -E\` at the pinned commit, and the
+# Coverage tab counts the files it matches as searched. A search that matched
+# nothing is stated too.
+#
+# searches:
+#   dispatchCallers: { pattern: '\\bdispatch\\(', paths: ["src/"], why: who routes a request }
 actors: {}
 anchors: {}
 stores: {}
+searches: {}
 `;
 const TEMPLATE_EXPLAIN_MAP = `# The structure of the code at the pinned commit: systems, containers,
 # components, code. The map carries breadth so the prose can carry depth, and a
 # node's \`files\` globs are what tell the Coverage tab a file was at least placed.
-# Seed it from \`thurview graph architecture\`.
+# Seed it from the directories: \`git ls-tree -d -r --name-only <commit>\`.
 nodes: []
 edges: []
 `;
@@ -375,7 +365,7 @@ const TEMPLATE_DESIGN_MAP = `# The structure the design proposes, with the struc
 # \`base\`, so the Map tab shows what it adds, changes and removes. A node under
 # \`nodes\` may own files that do not exist yet - that is a proposed part. A node
 # under \`base\` may not: it is a claim about today, and publish warns.
-# Seed base from \`thurview graph architecture\`.
+# Seed base from the directories: \`git ls-tree -d -r --name-only <commit>\`.
 nodes: []
 edges: []
 `;
@@ -576,6 +566,27 @@ const SPECS = {
         },
         examples: ["thurview open", "thurview open --review <id> --view map --no-browser"],
     },
+    export: {
+        description: "Write a published document to one self-contained HTML file that opens with no server",
+        flags: {
+            review: {
+                kind: "string",
+                help: "review id prefix (default: the review for this worktree)",
+            },
+            out: {
+                kind: "string",
+                help: "a .html file, or a folder to write index.html into (a Pages folder works)",
+            },
+            threads: {
+                kind: "boolean",
+                help: "show the reader's threads as static notes (use --no-threads to leave them out)",
+            },
+        },
+        examples: [
+            "thurview export --out review.html",
+            "thurview export --review <id> --out docs/reviews/auth --no-threads",
+        ],
+    },
     serve: {
         description: "Run the review server in the foreground",
         flags: {
@@ -616,28 +627,6 @@ const SPECS = {
             "thurview threads resolve <threadId>",
         ],
     },
-    graph: {
-        description: "Ask the code graph at the pinned commits: the interface delta, what the change reaches, callers, tests, architecture",
-        args: "interfaces|impact|callers <name>|tests-for <name>|architecture",
-        flags: {
-            review: { kind: "string", help: "review id prefix" },
-            base: {
-                kind: "string",
-                help: "instead of --review: base revision (default: trunk fork point)",
-            },
-            head: { kind: "string", help: "instead of --review: head revision (default: HEAD)" },
-            graph: { kind: "string", help: "callers, tests-for: head or base", default: "head" },
-            depth: { kind: "string", help: "how many caller hops to follow", default: "2" },
-        },
-        examples: [
-            "thurview graph interfaces",
-            "thurview graph impact",
-            "thurview graph impact --base main --head HEAD",
-            "thurview graph callers login",
-            "thurview graph tests-for login --graph base",
-            "thurview graph architecture",
-        ],
-    },
     forge: {
         description: "Read a pull or merge request through its forge, and post the review back to it",
         args: 'status|prior|pass|submit --file <path>|reply <threadId> --body "<text>"',
@@ -888,7 +877,7 @@ const commands = {
             guidance: await guidanceFiles(worktree),
             help: [
                 `Edit ${join(dir, "review.md")} and data.yaml, then run \`thurview publish --review ${short(review.id)}\``,
-                `Run \`thurview graph impact --review ${short(review.id)}\` to see what the change reaches`,
+                `Run \`git grep -n -w <symbol> ${head.slice(0, 12)} --\` in ${worktree} for who reaches a symbol the change moved`,
                 stat.additions + stat.deletions < 300
                     ? `Small change: run \`thurview publish --review ${short(review.id)} --view files --open\` now, then write the document`
                     : `Run \`git diff ${base.slice(0, 12)} ${head.slice(0, 12)}\` in ${worktree} to study the change`,
@@ -923,7 +912,7 @@ const commands = {
             scale: { filesInScope: pinned.inScope.length },
             guidance: await guidanceFiles(worktree),
             help: [
-                `Run \`thurview graph architecture --review ${short(review.id)}\` for the clusters, their hubs and the links between them`,
+                `Run \`git ls-tree -d -r --name-only ${commit.slice(0, 12)}\` in ${worktree} for the directories in scope`,
                 `Author ${join(dir, "map.yaml")} first: it carries the breadth the prose cannot`,
                 `Edit ${join(dir, "review.md")} and data.yaml, then run \`thurview publish --review ${short(review.id)}\``,
             ],
@@ -957,7 +946,7 @@ const commands = {
             scale: { filesInScope: pinned.inScope.length },
             guidance: await guidanceFiles(worktree),
             help: [
-                `Run \`thurview graph architecture --review ${short(review.id)}\` for the structure the design has to fit`,
+                `Run \`git grep -n -w <symbol> ${commit.slice(0, 12)} --\` in ${worktree} for who depends on what the design changes`,
                 `Declare in ${join(dir, "data.yaml")} what the design would add, change or remove, each anchored to the code it lands in today`,
                 `Edit ${join(dir, "review.md")}, then run \`thurview publish --review ${short(review.id)}\``,
             ],
@@ -1035,21 +1024,6 @@ const commands = {
         }
         const themeName = theme ? await registerTheme(theme.shiki) : undefined;
         const kind = kindOf(review);
-        // An explainer has one pinned commit, so there is no delta to derive: the
-        // panel above its document states coverage instead.
-        let interfaces = null;
-        if (kind === "review") {
-            try {
-                interfaces = await deltaFor(pinnedOf(review));
-            }
-            catch (e) {
-                diags.push({
-                    level: "warning",
-                    file: "review.md",
-                    message: `the interface delta is unavailable: ${e.message}`,
-                });
-            }
-        }
         const doc = await compileDocument({
             cwd: review.worktree,
             pins: review.pins,
@@ -1057,7 +1031,6 @@ const commands = {
             dataYaml: dataYaml ?? "",
             kind,
             ...(themeName ? { themeName } : {}),
-            interfaces,
         });
         diags.push(...doc.diagnostics);
         let map = null;
@@ -1095,13 +1068,11 @@ const commands = {
         let coverage = null;
         if (kind === "explainer") {
             try {
-                const graph = await import("./graph.js");
-                const g0 = await graph.graphAt(review.worktree, review.pins.head, dir);
                 coverage = computeCoverage({
                     commit: review.pins.head,
                     scope: review.binding.name,
                     allFiles: await g.listFiles(review.worktree, review.pins.head),
-                    graph: g0,
+                    searches: doc.searches,
                     anchored: Object.values(doc.document.anchors)
                         .map((a) => a.peek?.file)
                         .filter((f) => !!f),
@@ -1241,6 +1212,35 @@ const commands = {
             ],
         };
     },
+    async export(args) {
+        const p = parseFlags("export", args, spec("export").flags);
+        const out = str(p, "out");
+        if (!out)
+            throw new AxiError("--out is required", "VALIDATION_ERROR", [
+                "Run `thurview export --out review.html`, or `--out <folder>` for <folder>/index.html",
+            ]);
+        const review = await resolveReview(str(p, "review"), { terminal: true });
+        if (!review.revision)
+            throw new AxiError(`review ${short(review.id)} is not published yet`, "VALIDATION_ERROR", [
+                `Run \`thurview publish --review ${short(review.id)}\` first`,
+            ]);
+        const threads = p.flags["threads"] !== false;
+        const html = await exportReview(review, { threads });
+        const file = await localTarget(out).write(html);
+        return {
+            exported: {
+                id: short(review.id),
+                revision: review.revision,
+                file,
+                bytes: Buffer.byteLength(html),
+                threads,
+            },
+            help: [
+                "Open the file in any browser; it needs no thurview server and fetches nothing",
+                "Commit it to a Pages folder or copy it to a static host to share it",
+            ],
+        };
+    },
     async serve(args) {
         const p = parseFlags("serve", args, spec("serve").flags);
         const port = str(p, "port");
@@ -1358,154 +1358,6 @@ const commands = {
             await (handedQuestion ? listening.handOff() : listening.stop());
         }
     },
-    async graph(args) {
-        const sub = args[0];
-        const rest = args.slice(1);
-        const s = spec("graph").flags;
-        const help = [
-            "thurview graph interfaces",
-            "thurview graph impact",
-            "thurview graph callers <name> [--graph base]",
-            "thurview graph tests-for <name> [--graph base]",
-            "thurview graph architecture",
-        ];
-        if (!sub || !["interfaces", "impact", "callers", "tests-for", "architecture"].includes(sub))
-            throw new AxiError(`unknown graph command${sub ? ` ${sub}` : ""}`, "VALIDATION_ERROR", help);
-        const named = sub === "callers" || sub === "tests-for";
-        const p = parseFlags(`graph ${sub}`, rest, s, named ? 1 : 0);
-        const name = p.positional[0];
-        if (named && !name)
-            throw new AxiError(`graph ${sub} needs a symbol name`, "VALIDATION_ERROR", help);
-        const depth = Number(str(p, "depth") ?? "2");
-        if (!Number.isInteger(depth) || depth < 1)
-            throw new AxiError("--depth must be a positive integer", "VALIDATION_ERROR", help);
-        const side = str(p, "graph") ?? "head";
-        if (side !== "head" && side !== "base")
-            throw new AxiError("--graph must be head or base", "VALIDATION_ERROR", help);
-        const baseRef = str(p, "base");
-        const headRef = str(p, "head");
-        const commits = baseRef !== undefined || headRef !== undefined;
-        if (commits && str(p, "review"))
-            throw new AxiError("pass --review or --base/--head, not both", "VALIDATION_ERROR", help);
-        const graph = await import("./graph.js");
-        const review = commits ? null : await resolveReview(str(p, "review"));
-        let t;
-        if (review)
-            t = pinnedOf(review);
-        else {
-            const worktree = await worktreeOf(process.cwd());
-            if (!worktree)
-                throw new AxiError("not inside a git repository", "VALIDATION_ERROR", [
-                    "Run inside the source worktree, or pass --review <id>",
-                ]);
-            // No review directory owns these graphs, and a commit's graph is the same
-            // whoever asks, so they share one cache under the thurview home.
-            const pins = await pinRange(worktree, baseRef, headRef, "thurview graph impact --base <ref>");
-            t = { worktree, pins, dir: home() };
-        }
-        // A next step has to name the same commits, or it answers about another change.
-        const again = review ? "" : ` --base ${short(t.pins.base)} --head ${short(t.pins.head)}`;
-        if (review && kindOf(review) !== "review" && (sub === "interfaces" || sub === "impact"))
-            throw new AxiError(`graph ${sub} compares two commits; ${kindOf(review) === "design" ? "a design" : "an explainer"} is pinned to one`, "VALIDATION_ERROR", [
-                `Run \`thurview graph architecture --review ${short(review.id)}\` for the structure at that commit`,
-                `Run \`thurview graph callers <name> --review ${short(review.id)}\` to follow one symbol`,
-            ]);
-        const at = (commit) => graph.graphAt(t.worktree, commit, t.dir);
-        if (sub === "callers" || sub === "tests-for") {
-            const g = await at(side === "base" ? t.pins.base : t.pins.head);
-            const pins = {
-                graph: side,
-                commit: short(g.commit),
-                languages: graph.LANGUAGES.join(","),
-                truncated: g.truncated,
-            };
-            if (sub === "callers")
-                return {
-                    ...pins,
-                    symbol: name,
-                    callers: graph.callers(g, name),
-                    help: [`Run \`thurview graph tests-for ${name}${again}\` to see what exercises it`],
-                };
-            return {
-                ...pins,
-                symbol: name,
-                depth,
-                tests: graph.testsFor(g, name, depth),
-                help: [`Run \`thurview graph callers ${name}${again}\` for every reference`],
-            };
-        }
-        const base = await at(t.pins.base);
-        const head = await at(t.pins.head);
-        const pins = {
-            base: short(base.commit),
-            head: short(head.commit),
-            languages: graph.LANGUAGES.join(","),
-        };
-        if (sub === "interfaces") {
-            const delta = await deltaFor(t, base, head);
-            return {
-                ...pins,
-                verdict: delta.verdict,
-                interfaces: delta.entries.map((e) => ({
-                    id: e.id,
-                    change: e.change,
-                    name: e.name,
-                    was: e.was,
-                    kind: e.kind,
-                    file: e.file,
-                    line: e.line,
-                    graph: e.graph,
-                })),
-                internal: delta.internal,
-                unreadable: delta.unreadable,
-                truncated: delta.truncated,
-                help: [
-                    ...(review
-                        ? ["Write one capability line per entry in data.yaml under `interfaces`, keyed by id"]
-                        : []),
-                    `Run \`thurview graph callers <name>${again}\` to see who a removed or changed interface reached`,
-                ],
-            };
-        }
-        if (sub === "impact") {
-            const changes = await g.lineChanges(t.worktree, t.pins.base, t.pins.head);
-            return {
-                ...pins,
-                depth,
-                ...graph.impact(base, head, changes, depth),
-                help: [
-                    `Run \`thurview graph callers <name>${again}\` to follow one symbol`,
-                    `Run \`thurview graph architecture${again}\` for the module structure and its diff`,
-                ],
-            };
-        }
-        // An explainer and a design are both scoped to a path and pinned to one
-        // commit, so the structure they get back is that path's, not the
-        // repository's: for an explainer, the same bound the Coverage tab accounts
-        // for; for a design, the structure it has to fit.
-        if (review && kindOf(review) !== "review") {
-            const scope = review.binding.name;
-            const g0 = scopeGraph(head, scope);
-            const allFiles = await g.listFiles(t.worktree, t.pins.head);
-            const { diff: _diff, truncated: _truncated, ...rest } = graph.architecture(g0, g0);
-            return {
-                commit: short(head.commit),
-                scope,
-                languages: pins.languages,
-                truncated: scopeTruncated(allFiles, head, scope),
-                ...rest,
-                help: [
-                    "Seed map.yaml nodes from communities, their `files` from a community's files, and edges from edges",
-                    "A file in no community is outside the languages the graph reads; `thurview publish` counts those",
-                ],
-            };
-        }
-        return {
-            ...pins,
-            ...graph.architecture(base, head),
-            help: ["Seed map.yaml nodes from communities and edges from diff.added"],
-        };
-    },
     async threads(args) {
         const sub = args[0];
         const rest = args.slice(1);