diff --git a/docs/wip/bytecode-linking.md b/docs/wip/bytecode-linking.md
deleted file mode 100644
index 1d4e5b37..00000000
--- a/docs/wip/bytecode-linking.md
+++ /dev/null
@@ -1,204 +0,0 @@
-# Bytecode Linking Design
-
-## Scope
-
-**Design** the bytecode format to support future post-compilation linking, but **implement only**:
-
-- Emit linked bytecode (current behavior)
-- Emit unlinked bytecode (new: StringIds in instructions)
-- CLI dumps both for debugging
-- Runtime executes only linked bytecode, rejects unlinked
-
-**NOT implementing**: Actual relinking logic. The format supports it; we don't use it yet.
-
-## Chosen Design: Header Flag + StringId References
-
-**Key insight**: `StringId` and `NodeTypeId` are both `u16`. Instructions always store a `u16` in bytes 2-3 (node_type) and 4-5 (node_field). A header flag indicates how to interpret them.
-
-### StringId(0) Reservation
-
-Since `0` means "no constraint" (wildcard) in instruction bytes, `StringId(0)` can never be referenced by instructions. Reserve it as an easter egg:
-
-```
-strings[0] = "Beauty will save the world"   // Dostoevsky, The Idiot
-strings[1] = first actual string
-strings[2] = second actual string
-...
-```
-
-Actual string references use 1-based indices. The easter egg sits at index 0, visible to anyone who hexdumps the bytecode.
-
-### Unlinked Bytecode
-
-```
-Header: linked = false
-Match instruction bytes 2-3: StringId (index into string table)
-Match instruction bytes 4-5: StringId (index into string table)
-node_types section: empty (reserved)
-node_fields section: empty (reserved)
-```
-
-### Linked Bytecode (emitted via `LinkedQuery::emit()`)
-
-```
-Header: linked = true
-Match instruction bytes 2-3: NodeTypeId (grammar ID)
-Match instruction bytes 4-5: NodeFieldId (grammar ID)
-node_types section: [(NodeTypeId, StringId), ...] for verification
-node_fields section: [(NodeFieldId, StringId), ...] for verification
-```
-
-### Runtime Behavior
-
-- If `linked = false`: reject execution, require linking first
-- If `linked = true`: execute directly, optionally verify symbol tables match loaded grammar
-
----
-
-## Current Architecture
-
-### Compilation Flow
-
-```
-Query → Parse → Analyze → [Link against grammar] → Compile → Emit bytecode
-                              ↓
-                         node_type_ids: HashMap<Symbol, NodeTypeId>
-                         node_field_ids: HashMap<Symbol, NodeFieldId>
-```
-
-### Key Structures
-
-**MatchIR** (`bytecode/ir.rs:74-93`):
-
-```rust
-pub struct MatchIR {
-    pub node_type: Option<NonZeroU16>,  // Already numeric (tree-sitter ID)
-    pub node_field: Option<NonZeroU16>, // Already numeric
-    pub successors: Vec<Label>,         // Symbolic, resolved at emit
-    // ...
-}
-```
-
-**Match instruction wire format** (8 bytes minimum):
-
-```
-[0]   opcode + segment
-[1]   nav command
-[2-3] node_type (u16 LE, 0 = wildcard)  ← Target for relinking
-[4-5] node_field (u16 LE, 0 = wildcard) ← Target for relinking
-[6-7] next StepId or counts
-```
-
-### Two Emit Paths
-
-| Path                    | `node_type_ids` | Result                             |
-| ----------------------- | --------------- | ---------------------------------- |
-| `QueryAnalyzed::emit()` | `None`          | All node_type/field = 0 (wildcard) |
-| `LinkedQuery::emit()`   | `Some(HashMap)` | Actual grammar IDs                 |
-
-## Implementation Plan
-
-### 1. Header Flag
-
-Add `linked: bool` flag to `Header` struct:
-
-```rust
-// In bytecode/mod.rs or bytecode/header.rs
-pub struct Header {
-    // ... existing fields ...
-    pub flags: u16,  // bit 0 = linked
-}
-
-impl Header {
-    pub fn is_linked(&self) -> bool {
-        self.flags & 0x01 != 0
-    }
-}
-```
-
-### 2. StringTableBuilder: Reserve Index 0
-
-```rust
-impl StringTableBuilder {
-    pub fn new() -> Self {
-        let mut builder = Self { strings: Vec::new(), ... };
-        // Reserve index 0 for easter egg
-        builder.strings.push("Beauty will save the world".to_string());
-        builder
-    }
-
-    pub fn get_or_intern(&mut self, ...) -> StringId {
-        // Indices now start at 1
-        let id = StringId((self.strings.len()) as u16);  // No +1 needed, index 0 already occupied
-        // ...
-    }
-}
-```
-
-### 3. Compiler: Store StringId When Unlinked
-
-Modify `Compiler` to accept a "linked" flag and store `StringId` in unlinked mode:
-
-```rust
-fn resolve_node_type(&self, node: &ast::NamedNode) -> Option<NonZeroU16> {
-    let type_name = node.node_type()?.text();
-
-    if self.linked {
-        // Current behavior: resolve to NodeTypeId
-        self.node_type_ids?.get(type_name).map(|id| NonZeroU16::new(id.get()))
-    } else {
-        // New: store StringId instead
-        let string_id = self.strings.get_or_intern(type_name);
-        NonZeroU16::new(string_id.0)
-    }
-}
-```
-
-### 4. Emit Paths
-
-| Method                  | `linked` flag | Instructions contain | Symbol sections |
-| ----------------------- | ------------- | -------------------- | --------------- |
-| `QueryAnalyzed::emit()` | `false`       | StringId             | empty           |
-| `LinkedQuery::emit()`   | `true`        | NodeTypeId           | populated       |
-
-### 5. CLI: Dump Both Formats
-
-`debug --bytecode` should display:
-
-- Header linked flag
-- For unlinked: show string names from StringId
-- For linked: show grammar IDs with resolved names from symbol sections
-
-### 6. Runtime: Reject Unlinked
-
-```rust
-fn load_bytecode(bytes: &[u8]) -> Result<Runtime, Error> {
-    let header = Header::from_bytes(&bytes[..64]);
-    if !header.is_linked() {
-        return Err(Error::UnlinkedBytecode);
-    }
-    // ... continue loading
-}
-```
-
-Future work (NOT now): Implement `link_bytecode()` that walks transitions and resolves StringIds.
-
-## Files to Modify
-
-| File                                    | Changes                                                           |
-| --------------------------------------- | ----------------------------------------------------------------- |
-| `bytecode/mod.rs`                       | Add `flags` field to `Header`, `is_linked()` method               |
-| `query/emit.rs`                         | Reserve StringId(0) easter egg, set linked flag                   |
-| `query/compile.rs`                      | Store StringId when unlinked (needs access to StringTableBuilder) |
-| `plotnik-cli/src/commands/debug/mod.rs` | Display linked flag, decode instructions appropriately            |
-| `bytecode/dump.rs`                      | Update dump logic for linked/unlinked awareness                   |
-
-## Documentation Updates
-
-| File                                   | Changes                                                 |
-| -------------------------------------- | ------------------------------------------------------- |
-| `docs/binary-format/01-overview.md`    | Add `flags` field to header layout, document linked bit |
-| `docs/binary-format/02-header.md`      | Document `flags` field, `is_linked` semantics           |
-| `docs/binary-format/03-strings.md`     | Document StringId(0) reservation (easter egg)           |
-| `docs/binary-format/06-transitions.md` | Clarify bytes 2-5 meaning differs based on linked flag  |
-| `docs/wip/bytecode.md`                 | Update WIP notes on linking design                      |
diff --git a/docs/wip/cli-ux.md b/docs/wip/cli-ux.md
deleted file mode 100644
index 001300f8..00000000
--- a/docs/wip/cli-ux.md
+++ /dev/null
@@ -1,558 +0,0 @@
-# CLI UX Research
-
-> Consolidated research on building outstanding CLI user experiences.
-
-## Sources
-
-| Resource                                                                                                                                                   | Description                                      |
-| ---------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------ |
-| [Command Line Interface Guidelines](https://clig.dev/)                                                                                                     | The definitive guide (Prasad, Firshman, Tashian) |
-| [12 Factor CLI Apps](https://medium.com/@jdxcode/12-factor-cli-apps-dd3c227a0e46)                                                                          | Heroku/oclif principles                          |
-| [Heroku CLI Style Guide](https://devcenter.heroku.com/articles/cli-style-guide)                                                                            | Production-tested patterns                       |
-| [Atlassian: 10 Principles for Delightful CLIs](https://www.atlassian.com/blog/it-teams/10-design-principles-for-delightful-clis)                           | Design principles                                |
-| [Evil Martians: Progress Displays](https://evilmartians.com/chronicles/cli-ux-best-practices-3-patterns-for-improving-progress-displays)                   | Spinners, bars, status                           |
-| [Lucas Costa: UX Patterns](https://lucasfcosta.com/2022/06/01/ux-patterns-cli-tools.html)                                                                  | Practical patterns                               |
-| [Thoughtworks: CLI Design](https://www.thoughtworks.com/en-us/insights/blog/engineering-effectiveness/elevate-developer-experiences-cli-design-guidelines) | DX guidelines                                    |
-| [BetterCLI.org](https://bettercli.org/)                                                                                                                    | Comprehensive reference                          |
-
----
-
-## Part 1: Philosophy
-
-### Human-First Design
-
-Modern CLIs should prioritize human usability over machine compatibility. The historical UNIX approach optimized for scripts and terse output—today's CLIs serve humans directly.
-
-> "If a command is going to be used primarily by humans, it should be designed for humans first."
-
-### Composability
-
-Design programs as modular tools with clean interfaces. Standard mechanisms (stdin/stdout/stderr, signals, exit codes, plain text) ensure interoperability. Programs inevitably become parts of larger systems.
-
-### Consistency
-
-Terminal conventions are hardwired into users' fingers. Following existing patterns makes CLIs intuitive and guessable. Breaking conventions requires careful deliberation.
-
-### Discoverability
-
-CLIs needn't force users to memorize everything. Comprehensive help, examples, error suggestions, and progressive disclosure bridge the gap between CLI efficiency and GUI discoverability.
-
-### Robustness
-
-Software should handle unexpected input gracefully and _feel_ solid—immediate, responsive, reliable. This comes from attention to detail: keeping users informed, explaining errors clearly, avoiding scary stack traces.
-
-### Empathy
-
-Show users you're on their side. Exceed expectations through thoughtful design that demonstrates you've considered their problems carefully.
-
----
-
-## Part 2: Help & Documentation
-
-### The Help Flag
-
-These should all work equivalently:
-
-```
-myapp
-myapp --help
-myapp -h
-myapp help
-myapp help subcommand
-myapp subcommand --help
-```
-
-Adding `-h` to any invocation should display help, ignoring other flags.
-
-### Concise Default Help
-
-When required arguments are missing, show brief help:
-
-- Program description
-- One or two example invocations
-- Flag descriptions (unless numerous)
-- Instructions to pass `--help` for full details
-
-### Lead With Examples
-
-Users prefer examples over other documentation forms. Show common and complex use cases first, building understanding progressively.
-
-```
-USAGE
-  myapp <command> [options]
-
-EXAMPLES
-  $ myapp init                    # Start a new project
-  $ myapp build --release         # Build for production
-  $ myapp deploy --env staging    # Deploy to staging
-
-COMMANDS
-  init      Initialize new project
-  build     Compile the application
-  deploy    Deploy to environment
-
-Run 'myapp <command> --help' for details.
-```
-
-### Organize by Frequency
-
-Display common flags and commands first. Git shows "common commands used in various situations" upfront.
-
-### Include Links
-
-Add a website or GitHub link for feedback/issues. Link to web docs for subcommands when available.
-
----
-
-## Part 3: Output Design
-
-### Human-Readable First
-
-Optimize output for human consumption by default. Detect TTY to determine if output is interactive.
-
-### Machine-Readable Secondary
-
-- Keep output line-based for `grep`/`awk` compatibility
-- Provide `--plain` to disable human formatting
-- Provide `--json` for structured data (works with `jq`)
-
-### Success Output
-
-Display concise confirmation on success. Users need feedback, especially for long operations.
-
-```
-✓ Configuration saved to ~/.config/myapp/config.toml
-```
-
-Provide `-q`/`--quiet` for silent mode.
-
-### State Changes
-
-When modifying state, explain what happened:
-
-```
-Compiled 42 files in 1.2s
-  → target/release/myapp (2.3 MB)
-```
-
-### Suggest Next Steps
-
-In multi-step workflows, suggest commands:
-
-```
-Project initialized!
-
-Next steps:
-  cd my-project
-  myapp build
-  myapp run
-```
-
-### Tables
-
-Use tables for structured data. Never use borders—they're noisy and break parsing:
-
-**Bad:**
-
-```
-+--------+----------+
-| Name   | Status   |
-+--------+----------+
-| foo    | active   |
-+--------+----------+
-```
-
-**Good:**
-
-```
-NAME    STATUS
-foo     active
-bar     pending
-```
-
----
-
-## Part 4: Color & Visual Design
-
-### Intentional Color
-
-Use color to highlight important text and indicate status—not to decorate everything.
-
-| Color     | Use For                |
-| --------- | ---------------------- |
-| Red       | Errors                 |
-| Yellow    | Warnings               |
-| Green     | Success, confirmations |
-| Cyan/Blue | Info, emphasis         |
-| Magenta   | Special items          |
-| Gray/Dim  | Secondary info         |
-
-### Respect NO_COLOR
-
-Disable colors when:
-
-- stdout/stderr isn't a TTY
-- `NO_COLOR` environment variable is set
-- `TERM=dumb`
-- User passes `--no-color`
-
-### Symbols & Emoji
-
-Use sparingly to capture attention or add character:
-
-```
-✓ Build succeeded
-✗ Tests failed
-⚠ Deprecated API used
-```
-
-Avoid becoming cartoonish.
-
-### Hide Developer Output
-
-Don't display debug output, log levels, or stack traces by default. Reserve for `-v`/`--verbose` or `--debug`.
-
----
-
-## Part 5: Error Messages
-
-### The Golden Rules
-
-1. **Human-readable**: Plain language, no jargon
-2. **Actionable**: What went wrong + how to fix
-3. **Context-aware**: Show relevant values
-4. **Searchable**: Unique IDs, "SEO for errors"
-
-### Structure
-
-```
-error: Unable to read configuration file
-
-  File: ~/.config/myapp/config.toml
-  Cause: Permission denied
-
-Try: chmod +r ~/.config/myapp/config.toml
-
-For help: https://myapp.dev/docs/errors#E0042
-```
-
-### Formatting
-
-- Start with lowercase, no period at end
-- Position critical info at the end (where eyes rest)
-- Use red sparingly
-- Group similar errors under one header
-
-### Suggestions
-
-When users mistype, suggest corrections politely:
-
-```
-error: Unknown command 'buidl'
-
-Did you mean 'build'?
-```
-
-Don't auto-correct without confirmation—users may have made logical, not typographical, errors.
-
-### Exit Codes
-
-- `0`: Success
-- Non-zero: Failure
-- Map codes to failure modes for script detection
-
----
-
-## Part 6: Progress & Feedback
-
-### The 100ms Rule
-
-Print something within 100ms, even if it's just a spinner. Responsiveness makes programs feel solid.
-
-### Three Patterns
-
-#### 1. Spinners (Uncertain Duration)
-
-```
-⠋ Connecting to server...
-```
-
-Best for brief, sequential tasks. Update when specific actions complete.
-
-#### 2. X of Y (Measurable Progress)
-
-```
-Downloading: 42/100 files
-```
-
-Immediately signals stalls when numbers stop climbing.
-
-#### 3. Progress Bars (Multiple Tasks)
-
-```
-Building  [████████░░░░░░░░] 50%
-```
-
-Best for lengthy parallel processes.
-
-### Verb Tenses
-
-- Ongoing: gerund form ("Downloading...", "Building...")
-- Complete: past tense ("Downloaded", "Built")
-
-```
-⠋ Downloading dependencies...
-✓ Downloaded 42 packages
-⠋ Building project...
-✓ Built in 3.2s
-```
-
-### Long Operations
-
-For operations taking more than a few seconds:
-
-- Show animated indicator (proves program isn't frozen)
-- Display what's happening
-- Estimate completion time if possible
-
-### Disable When Not TTY
-
-Prevent progress bars from creating "Christmas trees" in CI logs.
-
----
-
-## Part 7: Arguments & Flags
-
-### Prefer Flags to Arguments
-
-Flags are more explicit and flexible:
-
-```bash
-# Unclear: which is source, which is dest?
-myapp copy file1.txt file2.txt
-
-# Clear
-myapp copy --from file1.txt --to file2.txt
-```
-
-Exception: common actions where brevity is worth memorizing (`cp src dest`).
-
-### Full-Length Versions
-
-Always provide long forms (`--help` alongside `-h`). Scripts benefit from clarity; users benefit from discoverability.
-
-### Standard Names
-
-| Flag            | Meaning                    |
-| --------------- | -------------------------- |
-| `-h, --help`    | Show help                  |
-| `--version`     | Show version               |
-| `-v, --verbose` | Verbose output             |
-| `-q, --quiet`   | Suppress output            |
-| `-f, --force`   | Skip confirmations         |
-| `-n, --dry-run` | Simulate without executing |
-| `-o, --output`  | Output file                |
-| `--json`        | JSON output                |
-| `--no-color`    | Disable colors             |
-| `--no-input`    | Disable prompts            |
-
-### Never Read Secrets From Flags
-
-Flags leak into `ps` output and shell history. Use `--password-file` or stdin.
-
----
-
-## Part 8: Interactivity
-
-### Check for TTY
-
-Only use prompts when stdin is interactive. This reliably distinguishes piped/scripted usage.
-
-### Never Require Prompts
-
-Always provide non-interactive alternatives via flags. When stdin isn't a TTY, skip prompts and require explicit flags.
-
-### Confirm Dangerous Actions
-
-| Danger Level | Approach                       |
-| ------------ | ------------------------------ |
-| Mild         | Optional confirmation          |
-| Moderate     | Prompt; offer `--dry-run`      |
-| Severe       | Require typing the target name |
-
-For scripts, accept `-f`/`--force` or `--confirm="name"`.
-
-### Escape Mechanisms
-
-- Ctrl-C should always work
-- Make exit methods clear
-- On second Ctrl-C, skip cleanup
-
----
-
-## Part 9: Subcommands
-
-### Structure
-
-For complex tools, use subcommands: `myapp <command> [options]`
-
-### Consistency
-
-Use identical conventions across all subcommands:
-
-- Same flag names
-- Same output formatting
-- Same error style
-
-### Naming
-
-Use `noun verb` (more common) or `verb noun`—be consistent:
-
-```
-myapp config get
-myapp config set
-myapp user list
-myapp user create
-```
-
-### Avoid Ambiguity
-
-Don't use similar names like "update" and "upgrade" interchangeably.
-
----
-
-## Part 10: Configuration
-
-### Precedence (High to Low)
-
-1. Flags (highest priority)
-2. Environment variables
-3. Project config (`.myapprc`, `myapp.toml`)
-4. User config (`~/.config/myapp/`)
-5. System config
-
-### XDG Specification
-
-Use `~/.config/` to reduce dotfile proliferation. Standard adopted by fish, neovim, tmux, and others.
-
-### Environment Variables
-
-| Variable   | Purpose               |
-| ---------- | --------------------- |
-| `NO_COLOR` | Disable colors        |
-| `DEBUG`    | Verbose output        |
-| `EDITOR`   | For editing prompts   |
-| `PAGER`    | Output pagination     |
-| `TERM`     | Terminal capabilities |
-
-### Secrets
-
-Never store in environment variables—too prone to leakage. Use credential files, pipes, or secret managers.
-
----
-
-## Part 11: Robustness
-
-### Validate Early
-
-Check input immediately. Provide clear, actionable errors before problems cascade.
-
-### Timeouts
-
-Configure reasonable defaults so programs don't hang on failed connections.
-
-### Crash-Only Design
-
-Build programs that can exit immediately without cleanup. Defer cleanup to next run.
-
-### Plan for Misuse
-
-Users will:
-
-- Wrap your program in scripts
-- Use poor network connections
-- Run multiple instances simultaneously
-- Use unexpected environments
-
-Design defensively.
-
----
-
-## Part 12: Future-Proofing
-
-### Keep Changes Additive
-
-Add new flags; don't modify existing ones. Avoid breaking changes.
-
-### Deprecation
-
-Warn users of upcoming changes:
-
-```
-warning: --old-flag is deprecated, use --new-flag instead
-         Will be removed in v3.0
-```
-
-### No Arbitrary Abbreviations
-
-Don't allow prefix matching (`i` for `install`). Explicit aliases are fine, but arbitrary abbreviations prevent future expansion.
-
----
-
-## Quick Reference Card
-
-### Do
-
-- `-h`/`--help` everywhere
-- Exit 0 on success, non-zero on failure
-- Errors to stderr, output to stdout
-- Support `--json` for scripting
-- Respect `NO_COLOR`
-- Show progress for >2 second operations
-- Suggest corrections for typos
-- Provide examples in help
-
-### Don't
-
-- Require interactive prompts
-- Read secrets from flags
-- Print debug output by default
-- Break grep/jq compatibility
-- Force colors in pipes
-- Leave users waiting without feedback
-- Use similar command names (update/upgrade)
-- Phone home without consent
-
----
-
-## Rust Libraries
-
-| Library                                              | Purpose             |
-| ---------------------------------------------------- | ------------------- |
-| [clap](https://github.com/clap-rs/clap)              | Argument parsing    |
-| [ratatui](https://github.com/ratatui-org/ratatui)    | TUI framework       |
-| [indicatif](https://github.com/console-rs/indicatif) | Progress bars       |
-| [console](https://github.com/console-rs/console)     | Terminal styling    |
-| [dialoguer](https://github.com/console-rs/dialoguer) | Interactive prompts |
-| [colored](https://github.com/colored-rs/colored)     | Colored output      |
-| [anyhow](https://github.com/dtolnay/anyhow)          | Error handling      |
-| [miette](https://github.com/zkat/miette)             | Fancy diagnostics   |
-
----
-
-## Plotnik-Specific Notes
-
-### Current Strengths
-
-- Diagnostics system already provides user-friendly errors
-- Multiple output formats (`--cst`, `--raw`, `--types`, `--bytecode`)
-
-### Opportunities
-
-1. **Examples in help**: Add usage examples to each subcommand
-2. **Suggest corrections**: For misspelled node kinds or capture names
-3. **Progress indication**: For large file processing
-4. **Exit codes**: Semantic codes for different error types
-5. **JSON output**: `--json` flag for machine consumption
-6. **Quiet mode**: `-q` for silent operation
-7. **Color semantics**: Consistent color usage across diagnostics
diff --git a/docs/wip/grammar-verify.md b/docs/wip/grammar-verify.md
deleted file mode 100644
index 288cef17..00000000
--- a/docs/wip/grammar-verify.md
+++ /dev/null
@@ -1,333 +0,0 @@
-# Grammar-Based Query Validation
-
-Validate that query structural patterns (sequences, anchors, parent-child relationships) are actually derivable from the grammar's production rules.
-
-## Problem Statement
-
-Current validation uses `node-types.json`, which is a **lossy summary**:
-
-```json
-{
-  "type": "function_declaration",
-  "fields": {
-    "name": { "types": [{ "type": "identifier" }] },
-    "body": { "types": [{ "type": "statement_block" }] }
-  }
-}
-```
-
-This tells you "identifier can be a child" but loses **sequence information**.
-
-The actual grammar (`grammar.json`) has production rules:
-
-```json
-{
-  "type": "SEQ",
-  "members": [
-    {
-      "type": "CHOICE",
-      "members": [{ "type": "STRING", "value": "async" }, { "type": "BLANK" }]
-    },
-    { "type": "STRING", "value": "function" },
-    {
-      "type": "FIELD",
-      "name": "name",
-      "content": { "type": "SYMBOL", "name": "identifier" }
-    },
-    { "type": "SYMBOL", "name": "_call_signature" },
-    {
-      "type": "FIELD",
-      "name": "body",
-      "content": { "type": "SYMBOL", "name": "statement_block" }
-    }
-  ]
-}
-```
-
-**Query**: `(function_declaration . (identifier) @name)` — first-child anchor on identifier
-
-**Reality**: First children are `"async"` (optional) then `"function"` keyword. Identifier is 3rd.
-
-**Verdict**: Pattern is **structurally impossible**. But `node-types.json` can't detect this.
-
-## Grammar JSON Structure
-
-Tree-sitter's `grammar.json` uses these combinators:
-
-| Type                                | Meaning                                |
-| ----------------------------------- | -------------------------------------- |
-| `SEQ`                               | Sequence of members (order matters)    |
-| `CHOICE`                            | Alternatives (any branch)              |
-| `REPEAT`                            | Zero or more (`*`)                     |
-| `REPEAT1`                           | One or more (`+`)                      |
-| `SYMBOL`                            | Reference to another rule              |
-| `STRING`                            | Literal token (becomes anonymous node) |
-| `PATTERN`                           | Regex for token                        |
-| `FIELD`                             | Named child                            |
-| `BLANK`                             | Epsilon (empty)                        |
-| `PREC` / `PREC_LEFT` / `PREC_RIGHT` | Precedence wrappers                    |
-| `ALIAS`                             | Rename a node                          |
-| `TOKEN` / `IMMEDIATE_TOKEN`         | Tokenization control                   |
-
-### Example: `array`
-
-```json
-{
-  "type": "SEQ",
-  "members": [
-    { "type": "STRING", "value": "[" },
-    {
-      "type": "CHOICE",
-      "members": [
-        {
-          "type": "SEQ",
-          "members": [
-            {
-              "type": "CHOICE",
-              "members": [
-                { "type": "SYMBOL", "name": "expression" },
-                { "type": "BLANK" }
-              ]
-            },
-            {
-              "type": "REPEAT",
-              "content": {
-                "type": "SEQ",
-                "members": [
-                  { "type": "STRING", "value": "," },
-                  {
-                    "type": "CHOICE",
-                    "members": [
-                      { "type": "SYMBOL", "name": "expression" },
-                      { "type": "BLANK" }
-                    ]
-                  }
-                ]
-              }
-            }
-          ]
-        },
-        { "type": "BLANK" }
-      ]
-    },
-    { "type": "STRING", "value": "]" }
-  ]
-}
-```
-
-Query `(array . (identifier))` with first-child anchor: **impossible** — `"["` is always first.
-
-## Proposed Architecture
-
-```
-┌─────────────────┐
-│  grammar.json   │
-└────────┬────────┘
-         ▼
-┌─────────────────┐
-│ Grammar IR      │  Parse SEQ/CHOICE/REPEAT/FIELD/SYMBOL/STRING/BLANK
-└────────┬────────┘
-         ▼
-┌─────────────────┐
-│ Visibility      │  Which elements produce visible tree nodes?
-│ Analysis        │  - SYMBOL(name) → visible if not `_` prefixed
-│                 │  - STRING("x") → anonymous node (visible)
-│                 │  - _hidden_rule → inline its children
-└────────┬────────┘
-         ▼
-┌─────────────────┐
-│ Child Sequence  │  For each node type, build NFA accepting
-│ NFA             │  valid child sequences
-└────────┬────────┘
-         ▼
-┌─────────────────┐
-│ Pattern Match   │  Query pattern → path constraints
-│                 │  Check: ∃ path through NFA matching pattern?
-└─────────────────┘
-```
-
-### 1. Grammar IR
-
-```rust
-enum GrammarExpr {
-    Seq(Vec<GrammarExpr>),
-    Choice(Vec<GrammarExpr>),
-    Repeat(Box<GrammarExpr>),      // *
-    Repeat1(Box<GrammarExpr>),     // +
-    Optional(Box<GrammarExpr>),    // implicit from CHOICE with BLANK
-    Symbol(String),                 // reference to rule
-    String(String),                 // literal token
-    Pattern(String),                // regex token
-    Field { name: String, content: Box<GrammarExpr> },
-    Blank,                          // epsilon
-    Prec { value: i32, content: Box<GrammarExpr> },
-    Alias { value: String, content: Box<GrammarExpr> },
-}
-```
-
-### 2. Visibility Analysis
-
-Determine which grammar elements produce visible tree nodes:
-
-- **Named rules** (`identifier`, `function_declaration`): Produce named nodes
-- **Hidden rules** (`_call_signature`, `_expression`): Inlined, don't produce nodes themselves
-- **STRING values** (`"function"`, `"["`): Produce anonymous nodes
-- **FIELD**: Just names a child, doesn't affect visibility
-
-Hidden rules must be recursively inlined to get the actual child sequence.
-
-### 3. Child Sequence NFA
-
-For each visible node type, build an NFA:
-
-- **States**: Positions in the flattened production rule
-- **Transitions**: Node types (named and anonymous)
-- **CHOICE**: ε-transitions to each branch
-- **REPEAT**: Loop transition back to start state
-- **BLANK**: ε-transition to next state
-
-Example for `function_declaration`:
-
-```
-[0] ──"async"?──► [1] ──"function"──► [2] ──identifier──► [3] ──(params)──► [4] ──statement_block──► [5]
-     └──────ε──────┘
-```
-
-### 4. Pattern Matching
-
-Query patterns become path constraints on the NFA:
-
-- **Regular child**: Must match a transition
-- **Gap (no anchor)**: Allow any path between
-- **First-child anchor (`. x`)**: x must be reachable from start with no prior named nodes
-- **Last-child anchor (`x .`)**: x must reach accepting state with no following named nodes
-- **Adjacent anchor (`x . y`)**: y immediately follows x (no intermediate named transitions)
-
-### 5. Validation Algorithm
-
-```
-fn validate_sequence(parent: NodeTypeId, pattern: &QueryPattern) -> Result<(), Diagnostic> {
-    let nfa = build_nfa(parent);
-    let constraints = pattern_to_constraints(pattern);
-
-    if !nfa.satisfies(constraints) {
-        return Err(Diagnostic::ImpossibleSequence {
-            parent,
-            pattern,
-            reason: explain_failure(nfa, constraints),
-        });
-    }
-    Ok(())
-}
-```
-
-## Complications
-
-### Hidden Rule Inlining
-
-`_call_signature` doesn't produce a node, but its children do:
-
-```
-_call_signature = SEQ(formal_parameters, type_annotation?)
-```
-
-When validating `function_declaration`, we inline this to get:
-
-```
-SEQ("async"?, "function", identifier, formal_parameters, type_annotation?, statement_block)
-```
-
-### Extras (Trivia)
-
-The grammar's `extras` field lists nodes that can appear anywhere (comments, whitespace):
-
-```json
-"extras": [
-  {"type": "SYMBOL", "name": "comment"},
-  {"type": "PATTERN", "value": "\\s"}
-]
-```
-
-These are handled by trivia-skipping in anchors, not by the NFA.
-
-### Supertypes
-
-`SYMBOL("expression")` matches any expression subtype. The NFA transition accepts any node that is a subtype of `expression`.
-
-### Partial Matching
-
-Query patterns don't match ALL children — they match a subsequence:
-
-- Query `{(a) (c)}` matches actual children `[a, b, c]` (b skipped)
-- The NFA must allow "gap" transitions between pattern elements
-
-### Anchor Semantics
-
-| Pattern             | Meaning                                                       |
-| ------------------- | ------------------------------------------------------------- |
-| `(P . (x))`         | x is first child of P (or first after trivia for named nodes) |
-| `(P (x) .)`         | x is last child of P                                          |
-| `(P (x) . (y))`     | y immediately follows x (no named nodes between)              |
-| `(P {. (x) (y) .})` | x is first AND y is last in the sequence                      |
-
-## Diagnostics
-
-```
-error[E0XX]: impossible child sequence
-  --> query.ptk:5:3
-   |
- 5 |   (function_declaration . (identifier) @name)
-   |                         ^^^^^^^^^^^^^^^^^
-   |
-   = note: `identifier` cannot be the first child of `function_declaration`
-   = note: the grammar requires `"function"` keyword before the name
-   = help: remove the first-child anchor: `(function_declaration (identifier) @name)`
-```
-
-## Effort Estimate
-
-| Component           | LOC       | Notes               |
-| ------------------- | --------- | ------------------- |
-| Grammar JSON parser | ~400      | Serde, known schema |
-| Grammar IR          | ~300      | Recursive enum      |
-| Visibility analysis | ~300      | Inline hidden rules |
-| NFA construction    | ~500      | Per node type       |
-| Pattern matching    | ~400      | Path satisfiability |
-| Integration         | ~200      | Hook into link.rs   |
-| Tests               | ~500      | Edge cases          |
-| **Total**           | **~2600** |                     |
-
-## Build-time vs Runtime
-
-**Option 1: Runtime**
-
-- Load `grammar.json` at link time
-- More flexible (supports dynamic languages)
-- Slower startup, more memory
-
-**Option 2: Build-time**
-
-- Pre-compile grammar to static NFA tables in `build.rs`
-- Faster, but larger binaries
-- Matches current `node-types.json` approach
-
-Recommendation: Start with runtime, optimize to build-time if needed.
-
-## Open Questions
-
-1. **How to handle recursive rules?** Some rules reference themselves (expressions containing expressions). NFAs must handle cycles.
-
-2. **Grammar version matching?** Different tree-sitter versions may have different grammars. Need to ensure grammar matches the compiled parser.
-
-3. **Error recovery nodes?** `ERROR` and `MISSING` nodes bypass normal grammar. Should they skip validation?
-
-4. **Performance?** Building NFAs for all node types might be expensive. Consider lazy construction.
-
-## Next Steps
-
-1. Parse `grammar.json` into IR (new module in `plotnik-core` or `plotnik-lib`)
-2. Implement visibility analysis and hidden rule inlining
-3. Build NFA for a simple node type (e.g., `array`)
-4. Validate a simple anchor pattern
-5. Expand to full pattern matching
-6. Integrate into `link.rs`
diff --git a/docs/wip/materializer.md b/docs/wip/materializer.md
deleted file mode 100644
index 2674e2f7..00000000
--- a/docs/wip/materializer.md
+++ /dev/null
@@ -1,282 +0,0 @@
-# Materializer Architecture
-
-## Overview
-
-The materializer transforms VM effect logs into structured output values.
-
-## Problem
-
-The VM produces `RuntimeEffect<'t>` items containing `tree_sitter::Node<'t>` references. These are tied to the tree's lifetime, preventing:
-
-- Aggregating values across multiple files
-- Storing values beyond the tree's lifetime
-- Clean API without lifetime pollution
-
-## Design
-
-### Effect Log
-
-The VM produces a single stream of effects (defined in `runtime-engine.md`):
-
-```rust
-pub enum RuntimeEffect<'t> {
-    Node(tree_sitter::Node<'t>),
-    Text(tree_sitter::Node<'t>),
-    Arr,
-    Push,
-    EndArr,
-    Obj,
-    Set(u16),       // member index
-    EndObj,
-    Enum(u16),      // variant index
-    EndEnum,
-    Clear,
-    Null,
-}
-
-struct EffectLog<'t>(Vec<RuntimeEffect<'t>>);
-```
-
-Lifetime `'t` denotes the parsed tree-sitter tree (per project conventions).
-
-The `Set` and `Enum` payloads are member indices into the type's members. Field/variant names come from type metadata (`TypesView` in `bytecode/module.rs`), not the effect itself.
-
-### Materializer Trait
-
-```rust
-pub trait Materializer<'t> {
-    type Output;
-
-    fn materialize(
-        &self,
-        effects: &[RuntimeEffect<'t>],
-        result_type: QTypeId,
-    ) -> Self::Output;
-}
-```
-
-- Context (source, type metadata) carried by the materializer struct
-- `result_type` from `Entrypoint.result_type` provides nominal type info
-
-### Value Types
-
-#### NodeHandle (Lifetime-free)
-
-Captures enough information to identify a node without holding a reference:
-
-```rust
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct NodeHandle {
-    pub start: u32,
-    pub end: u32,
-    pub kind_id: u16,
-}
-
-impl NodeHandle {
-    pub fn from_node(node: tree_sitter::Node) -> Self {
-        Self {
-            start: node.start_byte() as u32,
-            end: node.end_byte() as u32,
-            kind_id: node.kind_id(),
-        }
-    }
-
-    pub fn text<'a>(&self, source: &'a str) -> &'a str {
-        &source[self.start as usize..self.end as usize]
-    }
-}
-```
-
-#### Value (Output Type)
-
-Self-contained with resolved strings. Implements `serde::Serialize`.
-
-```rust
-#[derive(Clone, Debug, PartialEq, Serialize)]
-#[serde(untagged)]
-pub enum Value {
-    Null,
-    String(String),
-    Node(NodeHandle),
-    Array(Vec<Value>),
-    Object(Vec<(String, Value)>),  // preserves field order
-    Tagged { tag: String, data: Box<Value> },
-}
-```
-
-`Object` uses `Vec<(String, Value)>` to preserve field order from type metadata.
-
-### Serialization Format
-
-Per `lang-reference.md`, nodes serialize as:
-
-```json
-{
-  "kind": "identifier",
-  "text": "foo",
-  "start": { "row": 0, "column": 0 },
-  "end": { "row": 0, "column": 3 }
-}
-```
-
-Tagged unions serialize as:
-
-```json
-{
-  "$tag": "Assign",
-  "$data": { "target": "x", "value": { ... } }
-}
-```
-
-To serialize `NodeHandle` with positions, the serializer needs source text and the tree:
-
-```rust
-pub struct SerializeContext<'a> {
-    pub source: &'a str,
-    pub tree: &'a tree_sitter::Tree,
-    pub node_types: &'a [&'a str],  // kind_id -> kind name
-}
-```
-
-### ValueMaterializer
-
-Produces `Value` with resolved strings. Uses existing `TypesView` and `StringsView` from `bytecode/module.rs`.
-
-```rust
-pub struct ValueMaterializer<'ctx> {
-    source: &'ctx str,
-    types: TypesView<'ctx>,
-    strings: StringsView<'ctx>,
-}
-
-impl<'t> Materializer<'t> for ValueMaterializer<'_> {
-    type Output = Value;
-
-    fn materialize(
-        &self,
-        effects: &[RuntimeEffect<'t>],
-        result_type: QTypeId,
-    ) -> Value {
-        // Walk effects, resolve member indices to field names
-    }
-}
-```
-
-### Materialization Algorithm
-
-Walk the effect stream with a value stack:
-
-```rust
-fn materialize(&self, effects: &[RuntimeEffect<'t>], result_type: QTypeId) -> Value {
-    let mut stack: Vec<ValueBuilder> = vec![];
-    let mut current = ValueBuilder::new(result_type);
-
-    for effect in effects {
-        match effect {
-            RuntimeEffect::Node(n) => {
-                current.set_node(NodeHandle::from_node(*n));
-            }
-            RuntimeEffect::Text(n) => {
-                let text = n.utf8_text(self.source.as_bytes()).unwrap();
-                current.set_string(text.to_string());
-            }
-            RuntimeEffect::Null => {
-                current.set_null();
-            }
-            RuntimeEffect::Obj => {
-                stack.push(std::mem::replace(&mut current, ValueBuilder::object()));
-            }
-            RuntimeEffect::Set(idx) => {
-                let field_name = self.resolve_member_name(*idx);
-                current.set_field(field_name, stack.pop().unwrap().build());
-            }
-            RuntimeEffect::EndObj => {
-                let obj = std::mem::replace(&mut current, stack.pop().unwrap());
-                current.set_value(obj.build());
-            }
-            RuntimeEffect::Arr => {
-                stack.push(std::mem::replace(&mut current, ValueBuilder::array()));
-            }
-            RuntimeEffect::Push => {
-                current.push_item(stack.pop().unwrap().build());
-            }
-            RuntimeEffect::EndArr => {
-                let arr = std::mem::replace(&mut current, stack.pop().unwrap());
-                current.set_value(arr.build());
-            }
-            RuntimeEffect::Enum(idx) => {
-                let tag = self.resolve_variant_name(*idx);
-                stack.push(std::mem::replace(&mut current, ValueBuilder::tagged(tag)));
-            }
-            RuntimeEffect::EndEnum => {
-                let tagged = std::mem::replace(&mut current, stack.pop().unwrap());
-                current.set_value(tagged.build());
-            }
-            RuntimeEffect::Clear => {
-                current.clear();
-            }
-        }
-    }
-
-    current.build()
-}
-```
-
-## Usage
-
-### Single-file Execution
-
-```rust
-let module = Module::from_path("query.ptkb")?;
-let tree = parser.parse(source, None)?;
-
-let effects = vm.execute(&module, &tree, entrypoint)?;
-
-let materializer = ValueMaterializer::new(
-    source,
-    module.types(),
-    module.strings(),
-);
-let value = materializer.materialize(&effects.0, entrypoint.result_type);
-
-serde_json::to_writer(stdout, &value)?;
-```
-
-### Multi-file Aggregation
-
-`Value` is lifetime-free (uses `NodeHandle`), so results can outlive individual trees:
-
-```rust
-let mut all_results: Vec<(PathBuf, Value)> = vec![];
-
-for file in files {
-    let tree = parser.parse(&file.source, None)?;
-    let effects = vm.execute(&module, &tree, entrypoint)?;
-
-    let materializer = ValueMaterializer::new(
-        &file.source,
-        module.types(),
-        module.strings(),
-    );
-    let value = materializer.materialize(&effects.0, entrypoint.result_type);
-
-    all_results.push((file.path.clone(), value));
-    // tree dropped here, but value survives
-}
-```
-
-## Files
-
-| File                      | Purpose                                   |
-| ------------------------- | ----------------------------------------- |
-| `runtime/effect.rs`       | `RuntimeEffect` enum                      |
-| `runtime/value.rs`        | `Value` enum, `NodeHandle`                |
-| `runtime/materializer.rs` | `Materializer` trait, `ValueMaterializer` |
-| `runtime/serialize.rs`    | `SerializeContext`, node serialization    |
-
-## Related
-
-- `runtime-engine.md` — VM architecture, effect log
-- `lang-reference.md` — Output format specification
-- `bytecode/effects.rs` — `EffectOp` bytecode encoding
-- `bytecode/module.rs` — `TypesView`, `StringsView`
diff --git a/docs/wip/suppressive-captures.md b/docs/wip/suppressive-captures.md
deleted file mode 100644
index 6ef55d43..00000000
--- a/docs/wip/suppressive-captures.md
+++ /dev/null
@@ -1,497 +0,0 @@
-# Suppressive Captures Design
-
-> **Status**: Ready for implementation  
-> **Feature**: `@_` and `@_name` syntax for suppressing capture effects
-
-## Overview
-
-Suppressive captures allow matching patterns structurally without contributing to the output type or emitting effects. This is useful for:
-
-1. **Structural matching without capture** - Match a pattern for structure but don't emit its captures
-2. **Reusing definitions without their captures** - A definition like `Expr` has internal captures, but when using `(Expr)` you sometimes don't want those captures leaking up
-
-## Syntax
-
-```
-@_        ; anonymous suppressive capture
-@_name    ; named suppressive capture (name is documentation only)
-```
-
-Names like `@_foo` and `@_bar` never cause collisions - they're all equivalent to `@_`.
-
-## Example
-
-```
-Expr = (binary_expression left: (_) @left right: (_) @right)
-
-; Without suppression: @left, @right bubble up
-Query = (statement (Expr) @expr)
-; Output: { expr: Node, left: Node, right: Node }
-
-; With suppression: only @expr, internal captures discarded  
-Query = (statement (Expr) @_expr)
-; Output: { expr: Node }  -- WRONG, @_expr doesn't create field either
-
-; Correct usage - suppress internal captures, capture the node differently:
-Query = (statement { (Expr) @_ } @expr)
-; Output: { expr: Node }
-```
-
-## Semantics
-
-1. Suppressive captures **don't contribute to output type**
-2. All effects inside a suppressive capture are **suppressed** (not emitted to the effect log)
-3. **Nesting is supported**: `@_outer` containing `@_inner` works correctly (depth counter)
-4. The **inner pattern still matches structurally** - only effects are suppressed
-
----
-
-## Implementation Plan
-
-### Phase 1: Lexer & Parser
-
-#### 1.1 Lexer (`parser/cst.rs`)
-
-Add new token type after existing tokens (before `Id`):
-
-```rust
-/// Suppressive capture: @_ or @_name
-#[regex(r"@_[a-zA-Z0-9_]*")]
-SuppressiveCapture,
-```
-
-**Why before `Id`?** The `@` token is separate, but we want `@_` and `@_foo` to be recognized as a single token, not `@` + `Underscore` + `Id`.
-
-#### 1.2 Parser (`parser/grammar/fields.rs`)
-
-Modify `try_parse_capture` to handle the new token:
-
-```rust
-pub(crate) fn try_parse_capture(&mut self, checkpoint: Checkpoint) {
-    if self.currently_is(SyntaxKind::At) {
-        // Existing regular capture handling
-        self.start_node_at(checkpoint, SyntaxKind::Capture);
-        self.drain_trivia();
-        self.parse_capture_suffix();
-        self.finish_node();
-    } else if self.currently_is(SyntaxKind::SuppressiveCapture) {
-        // New: suppressive capture is a single token
-        self.start_node_at(checkpoint, SyntaxKind::Capture);
-        self.drain_trivia();
-        self.bump(); // consume SuppressiveCapture token
-        // Note: no type annotation allowed on suppressive captures
-        self.finish_node();
-    }
-}
-```
-
-#### 1.3 AST (`parser/ast.rs`)
-
-Add method to `CapturedExpr`:
-
-```rust
-impl CapturedExpr {
-    /// Returns true if this is a suppressive capture (@_ or @_name).
-    /// Suppressive captures match structurally but don't contribute to output.
-    pub fn is_suppressive(&self) -> bool {
-        self.0
-            .children_with_tokens()
-            .filter_map(|it| it.into_token())
-            .any(|t| t.kind() == SyntaxKind::SuppressiveCapture)
-    }
-    
-    // Existing name() method returns None for suppressive captures
-    // since SuppressiveCapture token != Id token
-}
-```
-
-### Phase 2: Type Inference
-
-#### 2.1 Type Inference (`analyze/type_check/infer.rs`)
-
-Modify `infer_captured_expr` to skip suppressive captures:
-
-```rust
-fn infer_captured_expr(&mut self, cap: &CapturedExpr) -> TermInfo {
-    // Suppressive captures don't contribute to output type
-    if cap.is_suppressive() {
-        // Still infer inner for structural validation, but don't create fields
-        return cap.inner()
-            .map(|i| self.infer_expr(&i))
-            .map(|info| TermInfo::new(info.arity, TypeFlow::Void))
-            .unwrap_or_else(TermInfo::void);
-    }
-    
-    // ... existing logic for regular captures
-}
-```
-
-**Key point**: We return `TypeFlow::Void` so no fields bubble up, but we still validate the inner expression.
-
-### Phase 3: Bytecode
-
-#### 3.1 Effect Opcodes (`bytecode/effects.rs`)
-
-Add new opcodes:
-
-```rust
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-#[repr(u8)]
-pub enum EffectOpcode {
-    Node = 0,
-    Arr = 1,
-    Push = 2,
-    EndArr = 3,
-    Obj = 4,
-    EndObj = 5,
-    Set = 6,
-    Enum = 7,
-    EndEnum = 8,
-    Text = 9,
-    Clear = 10,
-    Null = 11,
-    SuppressBegin = 12,  // NEW
-    SuppressEnd = 13,    // NEW
-}
-```
-
-Update `from_u8`:
-
-```rust
-fn from_u8(v: u8) -> Self {
-    match v {
-        // ... existing
-        12 => Self::SuppressBegin,
-        13 => Self::SuppressEnd,
-        _ => panic!("invalid effect opcode: {v}"),
-    }
-}
-```
-
-#### 3.2 Update Binary Format Docs (`docs/binary-format/06-transitions.md`)
-
-Add to the EffectOp table:
-
-```markdown
-| 12     | `SuppressBegin` | -                      |
-| 13     | `SuppressEnd`   | -                      |
-```
-
-### Phase 4: Compilation
-
-#### 4.1 Compile (`compile/expressions.rs`)
-
-Modify `compile_captured_inner` to handle suppressive captures:
-
-```rust
-pub(super) fn compile_captured_inner(
-    &mut self,
-    cap: &ast::CapturedExpr,
-    exit: Label,
-    nav_override: Option<Nav>,
-    outer_capture: CaptureEffects,
-) -> Label {
-    // Handle suppressive captures: emit SuppressBegin/End around inner
-    if cap.is_suppressive() {
-        let Some(inner) = cap.inner() else {
-            // Bare @_ with no inner - just emit suppress markers (no-op)
-            return self.emit_suppress_noop(exit, outer_capture);
-        };
-        
-        // Emit: SuppressBegin → inner → SuppressEnd → outer_effects → exit
-        
-        // 1. Emit SuppressEnd + outer capture effects → exit
-        let end_label = self.fresh_label();
-        let mut end_effects = vec![EffectIR::simple(EffectOpcode::SuppressEnd, 0)];
-        end_effects.extend(outer_capture.post);
-        self.instructions.push(Instruction::Match(MatchIR {
-            label: end_label,
-            nav: Nav::Stay,
-            node_type: None,
-            node_field: None,
-            pre_effects: vec![],
-            neg_fields: vec![],
-            post_effects: end_effects,
-            successors: vec![exit],
-        }));
-        
-        // 2. Compile inner expression → end_label
-        // Inner gets NO capture effects (suppressed)
-        let inner_entry = self.compile_expr_inner(
-            &inner,
-            end_label,
-            nav_override,
-            CaptureEffects::default(),
-        );
-        
-        // 3. Emit SuppressBegin → inner_entry
-        let begin_label = self.fresh_label();
-        self.instructions.push(Instruction::Match(MatchIR {
-            label: begin_label,
-            nav: Nav::Stay,
-            node_type: None,
-            node_field: None,
-            pre_effects: vec![],
-            neg_fields: vec![],
-            post_effects: vec![EffectIR::simple(EffectOpcode::SuppressBegin, 0)],
-            successors: vec![inner_entry],
-        }));
-        
-        return begin_label;
-    }
-    
-    // ... existing logic for regular captures
-}
-
-fn emit_suppress_noop(&mut self, exit: Label, outer_capture: CaptureEffects) -> Label {
-    // Bare @_ without inner - just pass through outer effects
-    if outer_capture.post.is_empty() {
-        return exit;
-    }
-    let label = self.fresh_label();
-    self.instructions.push(Instruction::Match(MatchIR {
-        label,
-        nav: Nav::Stay,
-        node_type: None,
-        node_field: None,
-        pre_effects: vec![],
-        neg_fields: vec![],
-        post_effects: outer_capture.post,
-        successors: vec![exit],
-    }));
-    label
-}
-```
-
-### Phase 5: VM Execution
-
-#### 5.1 Checkpoint (`engine/checkpoint.rs`)
-
-Add suppress depth to checkpoint:
-
-```rust
-#[derive(Clone, Copy, Debug)]
-pub struct Checkpoint {
-    pub descendant_index: u32,
-    pub effect_watermark: usize,
-    pub frame_index: Option<u32>,
-    pub recursion_depth: u32,
-    pub ip: u16,
-    pub skip_policy: Option<SkipPolicy>,
-    pub suppress_depth: u16,  // NEW
-}
-```
-
-#### 5.2 VM State (`engine/vm.rs`)
-
-Add suppress depth to VM:
-
-```rust
-pub struct VM<'t> {
-    cursor: CursorWrapper<'t>,
-    ip: u16,
-    frames: FrameArena,
-    checkpoints: CheckpointStack,
-    effects: EffectLog<'t>,
-    matched_node: Option<Node<'t>>,
-    exec_fuel: u32,
-    recursion_depth: u32,
-    limits: FuelLimits,
-    skip_call_nav: bool,
-    suppress_depth: u16,  // NEW
-}
-```
-
-Initialize in `new()`:
-
-```rust
-pub fn new(tree: &'t Tree, trivia_types: Vec<u16>, limits: FuelLimits) -> Self {
-    Self {
-        // ... existing
-        suppress_depth: 0,
-    }
-}
-```
-
-#### 5.3 Effect Emission (`engine/vm.rs`)
-
-Modify `emit_effect` to handle suppression:
-
-```rust
-fn emit_effect<T: Tracer>(&mut self, op: EffectOp, tracer: &mut T) {
-    use EffectOpcode::*;
-    
-    // Handle suppress control effects first
-    match op.opcode {
-        SuppressBegin => {
-            self.suppress_depth += 1;
-            tracer.trace_effect_suppressed(op); // Optional: for debugging
-            return; // Don't emit to log
-        }
-        SuppressEnd => {
-            self.suppress_depth = self.suppress_depth.saturating_sub(1);
-            tracer.trace_effect_suppressed(op); // Optional: for debugging
-            return; // Don't emit to log
-        }
-        _ => {}
-    }
-    
-    // Skip all other effects when suppressing
-    if self.suppress_depth > 0 {
-        tracer.trace_effect_suppressed(op); // Optional: for debugging
-        return;
-    }
-    
-    // ... existing effect handling (Node, Text, Arr, etc.)
-}
-```
-
-#### 5.4 Checkpoint Creation
-
-Update all checkpoint creation sites to include suppress_depth:
-
-```rust
-self.checkpoints.push(Checkpoint {
-    descendant_index: self.cursor.descendant_index(),
-    effect_watermark: self.effects.len(),
-    frame_index: self.frames.current(),
-    recursion_depth: self.recursion_depth,
-    ip: /* ... */,
-    skip_policy: /* ... */,
-    suppress_depth: self.suppress_depth,  // NEW
-});
-```
-
-#### 5.5 Backtrack Restoration
-
-Update `backtrack` to restore suppress_depth:
-
-```rust
-fn backtrack<T: Tracer>(&mut self, tracer: &mut T) -> Result<(), RuntimeError> {
-    let cp = self.checkpoints.pop().ok_or(RuntimeError::NoMatch)?;
-    tracer.trace_backtrack();
-    self.cursor.goto_descendant(cp.descendant_index);
-    self.effects.truncate(cp.effect_watermark);
-    self.frames.restore(cp.frame_index);
-    self.recursion_depth = cp.recursion_depth;
-    self.suppress_depth = cp.suppress_depth;  // NEW
-    
-    // ... rest of backtrack logic
-}
-```
-
----
-
-## Testing Strategy
-
-### Parser Tests (`parser/lexer_tests.rs`, `parser/cst_tests.rs`)
-
-```rust
-#[test]
-fn lex_suppressive_capture() {
-    let tokens = lex("@_");
-    assert_eq!(tokens[0].kind, SyntaxKind::SuppressiveCapture);
-}
-
-#[test]
-fn lex_named_suppressive_capture() {
-    let tokens = lex("@_foo_bar");
-    assert_eq!(tokens[0].kind, SyntaxKind::SuppressiveCapture);
-}
-
-#[test]
-fn parse_suppressive_capture() {
-    let input = "(identifier) @_";
-    let query = Query::expect_valid_ast(input).unwrap();
-    // Verify Capture node exists and is_suppressive() returns true
-}
-```
-
-### Type Inference Tests (`analyze/type_check/tests.rs`)
-
-```rust
-#[test]
-fn suppressive_capture_not_in_type() {
-    let input = "Q = (func (id) @_name)";
-    let query = build_query(input);
-    let type_info = query.type_context().get_def_type_by_name("Q");
-    // Verify output type has no fields (or only non-suppressed ones)
-}
-
-#[test]
-fn suppressive_capture_with_regular_sibling() {
-    let input = "Q = (func (id) @_ (num) @num)";
-    let query = build_query(input);
-    // Verify output type has only `num` field
-}
-```
-
-### Execution Tests (`engine/engine_tests.rs`)
-
-```rust
-#[test]
-fn suppressive_capture_no_effects() {
-    let query = "Q = (identifier) @_";
-    let source = "foo";
-    let effects = execute(query, source);
-    // Verify effect log is empty (or has no Node/Set effects)
-}
-
-#[test]
-fn suppressive_capture_nested() {
-    let query = "Q = { (a) @_outer { (b) @_inner } (c) @visible }";
-    let source = "a b c";
-    let effects = execute(query, source);
-    // Only @visible should produce effects
-}
-
-#[test]
-fn suppressive_capture_backtrack() {
-    let query = "Q = [(a) @_ (b) @visible]";
-    let source = "b";
-    let effects = execute(query, source);
-    // First branch fails (suppressed), second succeeds
-    // Verify suppress_depth correctly restored on backtrack
-}
-```
-
----
-
-## Files to Modify
-
-| File | Changes |
-|------|---------|
-| `parser/cst.rs` | Add `SuppressiveCapture` token |
-| `parser/grammar/fields.rs` | Handle `SuppressiveCapture` in `try_parse_capture` |
-| `parser/ast.rs` | Add `is_suppressive()` method to `CapturedExpr` |
-| `analyze/type_check/infer.rs` | Skip suppressive captures in `infer_captured_expr` |
-| `bytecode/effects.rs` | Add `SuppressBegin`, `SuppressEnd` opcodes |
-| `compile/expressions.rs` | Emit suppress effects in `compile_captured_inner` |
-| `engine/checkpoint.rs` | Add `suppress_depth` to `Checkpoint` |
-| `engine/vm.rs` | Add `suppress_depth` to VM, handle in `emit_effect`/`backtrack` |
-| `docs/lang-reference.md` | Document suppressive capture syntax |
-| `docs/binary-format/06-transitions.md` | Document new effect opcodes |
-
----
-
-## Edge Cases to Consider
-
-1. **Bare `@_` without inner expression**: Should be a no-op (valid but useless)
-2. **Type annotation on suppressive capture**: Should be a parse error (no `@_name :: Type`)
-3. **Suppressive capture as row capture**: `{...}* @_` should suppress the entire array
-4. **Nested regular inside suppressive**: `@_ { (a) @inner }` - `@inner` is suppressed too
-5. **Suppressive inside regular**: `@outer { (a) @_ }` - `@outer` produces effects, inner is suppressed
-
----
-
-## Implementation Order
-
-1. **Lexer + Parser** - Get syntax working first
-2. **AST helper** - `is_suppressive()` method  
-3. **Type inference** - Skip suppressive in type computation
-4. **Bytecode opcodes** - Add `SuppressBegin`/`SuppressEnd`
-5. **Compilation** - Emit suppress effects around inner
-6. **VM checkpoint** - Add `suppress_depth` field
-7. **VM execution** - Handle suppress mode in `emit_effect`
-8. **Tests** - Parser, type inference, execution
-9. **Documentation** - Update lang-reference.md